mirror of https://github.com/gogs/gogs.git
3075 lines
105 KiB
Go
3075 lines
105 KiB
Go
// Code generated by go-mockgen 1.3.3; DO NOT EDIT.
|
|
//
|
|
// This file was generated by running `go-mockgen` at the root of this repository.
|
|
// To add additional mocks to this or another package, add a new entry to the
|
|
// mockgen.yaml file in the root of this repository.
|
|
|
|
package lfs
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
|
|
db "gogs.io/gogs/internal/db"
|
|
lfsutil "gogs.io/gogs/internal/lfsutil"
|
|
)
|
|
|
|
// MockAccessTokensStore is a mock implementation of the AccessTokensStore
|
|
// interface (from the package gogs.io/gogs/internal/db) used for unit
|
|
// testing.
|
|
type MockAccessTokensStore struct {
|
|
// CreateFunc is an instance of a mock function object controlling the
|
|
// behavior of the method Create.
|
|
CreateFunc *AccessTokensStoreCreateFunc
|
|
// DeleteByIDFunc is an instance of a mock function object controlling
|
|
// the behavior of the method DeleteByID.
|
|
DeleteByIDFunc *AccessTokensStoreDeleteByIDFunc
|
|
// GetBySHA1Func is an instance of a mock function object controlling
|
|
// the behavior of the method GetBySHA1.
|
|
GetBySHA1Func *AccessTokensStoreGetBySHA1Func
|
|
// ListFunc is an instance of a mock function object controlling the
|
|
// behavior of the method List.
|
|
ListFunc *AccessTokensStoreListFunc
|
|
// TouchFunc is an instance of a mock function object controlling the
|
|
// behavior of the method Touch.
|
|
TouchFunc *AccessTokensStoreTouchFunc
|
|
}
|
|
|
|
// NewMockAccessTokensStore creates a new mock of the AccessTokensStore
|
|
// interface. All methods return zero values for all results, unless
|
|
// overwritten.
|
|
func NewMockAccessTokensStore() *MockAccessTokensStore {
|
|
return &MockAccessTokensStore{
|
|
CreateFunc: &AccessTokensStoreCreateFunc{
|
|
defaultHook: func(context.Context, int64, string) (r0 *db.AccessToken, r1 error) {
|
|
return
|
|
},
|
|
},
|
|
DeleteByIDFunc: &AccessTokensStoreDeleteByIDFunc{
|
|
defaultHook: func(context.Context, int64, int64) (r0 error) {
|
|
return
|
|
},
|
|
},
|
|
GetBySHA1Func: &AccessTokensStoreGetBySHA1Func{
|
|
defaultHook: func(context.Context, string) (r0 *db.AccessToken, r1 error) {
|
|
return
|
|
},
|
|
},
|
|
ListFunc: &AccessTokensStoreListFunc{
|
|
defaultHook: func(context.Context, int64) (r0 []*db.AccessToken, r1 error) {
|
|
return
|
|
},
|
|
},
|
|
TouchFunc: &AccessTokensStoreTouchFunc{
|
|
defaultHook: func(context.Context, int64) (r0 error) {
|
|
return
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// NewStrictMockAccessTokensStore creates a new mock of the
|
|
// AccessTokensStore interface. All methods panic on invocation, unless
|
|
// overwritten.
|
|
func NewStrictMockAccessTokensStore() *MockAccessTokensStore {
|
|
return &MockAccessTokensStore{
|
|
CreateFunc: &AccessTokensStoreCreateFunc{
|
|
defaultHook: func(context.Context, int64, string) (*db.AccessToken, error) {
|
|
panic("unexpected invocation of MockAccessTokensStore.Create")
|
|
},
|
|
},
|
|
DeleteByIDFunc: &AccessTokensStoreDeleteByIDFunc{
|
|
defaultHook: func(context.Context, int64, int64) error {
|
|
panic("unexpected invocation of MockAccessTokensStore.DeleteByID")
|
|
},
|
|
},
|
|
GetBySHA1Func: &AccessTokensStoreGetBySHA1Func{
|
|
defaultHook: func(context.Context, string) (*db.AccessToken, error) {
|
|
panic("unexpected invocation of MockAccessTokensStore.GetBySHA1")
|
|
},
|
|
},
|
|
ListFunc: &AccessTokensStoreListFunc{
|
|
defaultHook: func(context.Context, int64) ([]*db.AccessToken, error) {
|
|
panic("unexpected invocation of MockAccessTokensStore.List")
|
|
},
|
|
},
|
|
TouchFunc: &AccessTokensStoreTouchFunc{
|
|
defaultHook: func(context.Context, int64) error {
|
|
panic("unexpected invocation of MockAccessTokensStore.Touch")
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// NewMockAccessTokensStoreFrom creates a new mock of the
|
|
// MockAccessTokensStore interface. All methods delegate to the given
|
|
// implementation, unless overwritten.
|
|
func NewMockAccessTokensStoreFrom(i db.AccessTokensStore) *MockAccessTokensStore {
|
|
return &MockAccessTokensStore{
|
|
CreateFunc: &AccessTokensStoreCreateFunc{
|
|
defaultHook: i.Create,
|
|
},
|
|
DeleteByIDFunc: &AccessTokensStoreDeleteByIDFunc{
|
|
defaultHook: i.DeleteByID,
|
|
},
|
|
GetBySHA1Func: &AccessTokensStoreGetBySHA1Func{
|
|
defaultHook: i.GetBySHA1,
|
|
},
|
|
ListFunc: &AccessTokensStoreListFunc{
|
|
defaultHook: i.List,
|
|
},
|
|
TouchFunc: &AccessTokensStoreTouchFunc{
|
|
defaultHook: i.Touch,
|
|
},
|
|
}
|
|
}
|
|
|
|
// AccessTokensStoreCreateFunc describes the behavior when the Create method
|
|
// of the parent MockAccessTokensStore instance is invoked.
|
|
type AccessTokensStoreCreateFunc struct {
|
|
defaultHook func(context.Context, int64, string) (*db.AccessToken, error)
|
|
hooks []func(context.Context, int64, string) (*db.AccessToken, error)
|
|
history []AccessTokensStoreCreateFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// Create delegates to the next hook function in the queue and stores the
|
|
// parameter and result values of this invocation.
|
|
func (m *MockAccessTokensStore) Create(v0 context.Context, v1 int64, v2 string) (*db.AccessToken, error) {
|
|
r0, r1 := m.CreateFunc.nextHook()(v0, v1, v2)
|
|
m.CreateFunc.appendCall(AccessTokensStoreCreateFuncCall{v0, v1, v2, r0, r1})
|
|
return r0, r1
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the Create method of the
|
|
// parent MockAccessTokensStore instance is invoked and the hook queue is
|
|
// empty.
|
|
func (f *AccessTokensStoreCreateFunc) SetDefaultHook(hook func(context.Context, int64, string) (*db.AccessToken, error)) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// Create method of the parent MockAccessTokensStore instance invokes the
|
|
// hook at the front of the queue and discards it. After the queue is empty,
|
|
// the default hook function is invoked for any future action.
|
|
func (f *AccessTokensStoreCreateFunc) PushHook(hook func(context.Context, int64, string) (*db.AccessToken, error)) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *AccessTokensStoreCreateFunc) SetDefaultReturn(r0 *db.AccessToken, r1 error) {
|
|
f.SetDefaultHook(func(context.Context, int64, string) (*db.AccessToken, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *AccessTokensStoreCreateFunc) PushReturn(r0 *db.AccessToken, r1 error) {
|
|
f.PushHook(func(context.Context, int64, string) (*db.AccessToken, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
func (f *AccessTokensStoreCreateFunc) nextHook() func(context.Context, int64, string) (*db.AccessToken, error) {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *AccessTokensStoreCreateFunc) appendCall(r0 AccessTokensStoreCreateFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of AccessTokensStoreCreateFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *AccessTokensStoreCreateFunc) History() []AccessTokensStoreCreateFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]AccessTokensStoreCreateFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// AccessTokensStoreCreateFuncCall is an object that describes an invocation
|
|
// of method Create on an instance of MockAccessTokensStore.
|
|
type AccessTokensStoreCreateFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Arg2 is the value of the 3rd argument passed to this method
|
|
// invocation.
|
|
Arg2 string
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 *db.AccessToken
|
|
// Result1 is the value of the 2nd result returned from this method
|
|
// invocation.
|
|
Result1 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c AccessTokensStoreCreateFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1, c.Arg2}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c AccessTokensStoreCreateFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0, c.Result1}
|
|
}
|
|
|
|
// AccessTokensStoreDeleteByIDFunc describes the behavior when the
|
|
// DeleteByID method of the parent MockAccessTokensStore instance is
|
|
// invoked.
|
|
type AccessTokensStoreDeleteByIDFunc struct {
|
|
defaultHook func(context.Context, int64, int64) error
|
|
hooks []func(context.Context, int64, int64) error
|
|
history []AccessTokensStoreDeleteByIDFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// DeleteByID delegates to the next hook function in the queue and stores
|
|
// the parameter and result values of this invocation.
|
|
func (m *MockAccessTokensStore) DeleteByID(v0 context.Context, v1 int64, v2 int64) error {
|
|
r0 := m.DeleteByIDFunc.nextHook()(v0, v1, v2)
|
|
m.DeleteByIDFunc.appendCall(AccessTokensStoreDeleteByIDFuncCall{v0, v1, v2, r0})
|
|
return r0
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the DeleteByID method of
|
|
// the parent MockAccessTokensStore instance is invoked and the hook queue
|
|
// is empty.
|
|
func (f *AccessTokensStoreDeleteByIDFunc) SetDefaultHook(hook func(context.Context, int64, int64) error) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// DeleteByID method of the parent MockAccessTokensStore instance invokes
|
|
// the hook at the front of the queue and discards it. After the queue is
|
|
// empty, the default hook function is invoked for any future action.
|
|
func (f *AccessTokensStoreDeleteByIDFunc) PushHook(hook func(context.Context, int64, int64) error) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *AccessTokensStoreDeleteByIDFunc) SetDefaultReturn(r0 error) {
|
|
f.SetDefaultHook(func(context.Context, int64, int64) error {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *AccessTokensStoreDeleteByIDFunc) PushReturn(r0 error) {
|
|
f.PushHook(func(context.Context, int64, int64) error {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
func (f *AccessTokensStoreDeleteByIDFunc) nextHook() func(context.Context, int64, int64) error {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *AccessTokensStoreDeleteByIDFunc) appendCall(r0 AccessTokensStoreDeleteByIDFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of AccessTokensStoreDeleteByIDFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *AccessTokensStoreDeleteByIDFunc) History() []AccessTokensStoreDeleteByIDFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]AccessTokensStoreDeleteByIDFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// AccessTokensStoreDeleteByIDFuncCall is an object that describes an
|
|
// invocation of method DeleteByID on an instance of MockAccessTokensStore.
|
|
type AccessTokensStoreDeleteByIDFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Arg2 is the value of the 3rd argument passed to this method
|
|
// invocation.
|
|
Arg2 int64
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c AccessTokensStoreDeleteByIDFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1, c.Arg2}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c AccessTokensStoreDeleteByIDFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0}
|
|
}
|
|
|
|
// AccessTokensStoreGetBySHA1Func describes the behavior when the GetBySHA1
|
|
// method of the parent MockAccessTokensStore instance is invoked.
|
|
type AccessTokensStoreGetBySHA1Func struct {
|
|
defaultHook func(context.Context, string) (*db.AccessToken, error)
|
|
hooks []func(context.Context, string) (*db.AccessToken, error)
|
|
history []AccessTokensStoreGetBySHA1FuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// GetBySHA1 delegates to the next hook function in the queue and stores the
|
|
// parameter and result values of this invocation.
|
|
func (m *MockAccessTokensStore) GetBySHA1(v0 context.Context, v1 string) (*db.AccessToken, error) {
|
|
r0, r1 := m.GetBySHA1Func.nextHook()(v0, v1)
|
|
m.GetBySHA1Func.appendCall(AccessTokensStoreGetBySHA1FuncCall{v0, v1, r0, r1})
|
|
return r0, r1
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the GetBySHA1 method of
|
|
// the parent MockAccessTokensStore instance is invoked and the hook queue
|
|
// is empty.
|
|
func (f *AccessTokensStoreGetBySHA1Func) SetDefaultHook(hook func(context.Context, string) (*db.AccessToken, error)) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// GetBySHA1 method of the parent MockAccessTokensStore instance invokes the
|
|
// hook at the front of the queue and discards it. After the queue is empty,
|
|
// the default hook function is invoked for any future action.
|
|
func (f *AccessTokensStoreGetBySHA1Func) PushHook(hook func(context.Context, string) (*db.AccessToken, error)) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *AccessTokensStoreGetBySHA1Func) SetDefaultReturn(r0 *db.AccessToken, r1 error) {
|
|
f.SetDefaultHook(func(context.Context, string) (*db.AccessToken, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *AccessTokensStoreGetBySHA1Func) PushReturn(r0 *db.AccessToken, r1 error) {
|
|
f.PushHook(func(context.Context, string) (*db.AccessToken, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
func (f *AccessTokensStoreGetBySHA1Func) nextHook() func(context.Context, string) (*db.AccessToken, error) {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *AccessTokensStoreGetBySHA1Func) appendCall(r0 AccessTokensStoreGetBySHA1FuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of AccessTokensStoreGetBySHA1FuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *AccessTokensStoreGetBySHA1Func) History() []AccessTokensStoreGetBySHA1FuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]AccessTokensStoreGetBySHA1FuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// AccessTokensStoreGetBySHA1FuncCall is an object that describes an
|
|
// invocation of method GetBySHA1 on an instance of MockAccessTokensStore.
|
|
type AccessTokensStoreGetBySHA1FuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 string
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 *db.AccessToken
|
|
// Result1 is the value of the 2nd result returned from this method
|
|
// invocation.
|
|
Result1 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c AccessTokensStoreGetBySHA1FuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c AccessTokensStoreGetBySHA1FuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0, c.Result1}
|
|
}
|
|
|
|
// AccessTokensStoreListFunc describes the behavior when the List method of
|
|
// the parent MockAccessTokensStore instance is invoked.
|
|
type AccessTokensStoreListFunc struct {
|
|
defaultHook func(context.Context, int64) ([]*db.AccessToken, error)
|
|
hooks []func(context.Context, int64) ([]*db.AccessToken, error)
|
|
history []AccessTokensStoreListFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// List delegates to the next hook function in the queue and stores the
|
|
// parameter and result values of this invocation.
|
|
func (m *MockAccessTokensStore) List(v0 context.Context, v1 int64) ([]*db.AccessToken, error) {
|
|
r0, r1 := m.ListFunc.nextHook()(v0, v1)
|
|
m.ListFunc.appendCall(AccessTokensStoreListFuncCall{v0, v1, r0, r1})
|
|
return r0, r1
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the List method of the
|
|
// parent MockAccessTokensStore instance is invoked and the hook queue is
|
|
// empty.
|
|
func (f *AccessTokensStoreListFunc) SetDefaultHook(hook func(context.Context, int64) ([]*db.AccessToken, error)) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// List method of the parent MockAccessTokensStore instance invokes the hook
|
|
// at the front of the queue and discards it. After the queue is empty, the
|
|
// default hook function is invoked for any future action.
|
|
func (f *AccessTokensStoreListFunc) PushHook(hook func(context.Context, int64) ([]*db.AccessToken, error)) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *AccessTokensStoreListFunc) SetDefaultReturn(r0 []*db.AccessToken, r1 error) {
|
|
f.SetDefaultHook(func(context.Context, int64) ([]*db.AccessToken, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *AccessTokensStoreListFunc) PushReturn(r0 []*db.AccessToken, r1 error) {
|
|
f.PushHook(func(context.Context, int64) ([]*db.AccessToken, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
func (f *AccessTokensStoreListFunc) nextHook() func(context.Context, int64) ([]*db.AccessToken, error) {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *AccessTokensStoreListFunc) appendCall(r0 AccessTokensStoreListFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of AccessTokensStoreListFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *AccessTokensStoreListFunc) History() []AccessTokensStoreListFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]AccessTokensStoreListFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// AccessTokensStoreListFuncCall is an object that describes an invocation
|
|
// of method List on an instance of MockAccessTokensStore.
|
|
type AccessTokensStoreListFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 []*db.AccessToken
|
|
// Result1 is the value of the 2nd result returned from this method
|
|
// invocation.
|
|
Result1 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c AccessTokensStoreListFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c AccessTokensStoreListFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0, c.Result1}
|
|
}
|
|
|
|
// AccessTokensStoreTouchFunc describes the behavior when the Touch method
|
|
// of the parent MockAccessTokensStore instance is invoked.
|
|
type AccessTokensStoreTouchFunc struct {
|
|
defaultHook func(context.Context, int64) error
|
|
hooks []func(context.Context, int64) error
|
|
history []AccessTokensStoreTouchFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// Touch delegates to the next hook function in the queue and stores the
|
|
// parameter and result values of this invocation.
|
|
func (m *MockAccessTokensStore) Touch(v0 context.Context, v1 int64) error {
|
|
r0 := m.TouchFunc.nextHook()(v0, v1)
|
|
m.TouchFunc.appendCall(AccessTokensStoreTouchFuncCall{v0, v1, r0})
|
|
return r0
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the Touch method of the
|
|
// parent MockAccessTokensStore instance is invoked and the hook queue is
|
|
// empty.
|
|
func (f *AccessTokensStoreTouchFunc) SetDefaultHook(hook func(context.Context, int64) error) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// Touch method of the parent MockAccessTokensStore instance invokes the
|
|
// hook at the front of the queue and discards it. After the queue is empty,
|
|
// the default hook function is invoked for any future action.
|
|
func (f *AccessTokensStoreTouchFunc) PushHook(hook func(context.Context, int64) error) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *AccessTokensStoreTouchFunc) SetDefaultReturn(r0 error) {
|
|
f.SetDefaultHook(func(context.Context, int64) error {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *AccessTokensStoreTouchFunc) PushReturn(r0 error) {
|
|
f.PushHook(func(context.Context, int64) error {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
func (f *AccessTokensStoreTouchFunc) nextHook() func(context.Context, int64) error {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *AccessTokensStoreTouchFunc) appendCall(r0 AccessTokensStoreTouchFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of AccessTokensStoreTouchFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *AccessTokensStoreTouchFunc) History() []AccessTokensStoreTouchFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]AccessTokensStoreTouchFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// AccessTokensStoreTouchFuncCall is an object that describes an invocation
|
|
// of method Touch on an instance of MockAccessTokensStore.
|
|
type AccessTokensStoreTouchFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c AccessTokensStoreTouchFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c AccessTokensStoreTouchFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0}
|
|
}
|
|
|
|
// MockLFSStore is a mock implementation of the LFSStore interface (from the
|
|
// package gogs.io/gogs/internal/db) used for unit testing.
|
|
type MockLFSStore struct {
|
|
// CreateObjectFunc is an instance of a mock function object controlling
|
|
// the behavior of the method CreateObject.
|
|
CreateObjectFunc *LFSStoreCreateObjectFunc
|
|
// GetObjectByOIDFunc is an instance of a mock function object
|
|
// controlling the behavior of the method GetObjectByOID.
|
|
GetObjectByOIDFunc *LFSStoreGetObjectByOIDFunc
|
|
// GetObjectsByOIDsFunc is an instance of a mock function object
|
|
// controlling the behavior of the method GetObjectsByOIDs.
|
|
GetObjectsByOIDsFunc *LFSStoreGetObjectsByOIDsFunc
|
|
}
|
|
|
|
// NewMockLFSStore creates a new mock of the LFSStore interface. All methods
|
|
// return zero values for all results, unless overwritten.
|
|
func NewMockLFSStore() *MockLFSStore {
|
|
return &MockLFSStore{
|
|
CreateObjectFunc: &LFSStoreCreateObjectFunc{
|
|
defaultHook: func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) (r0 error) {
|
|
return
|
|
},
|
|
},
|
|
GetObjectByOIDFunc: &LFSStoreGetObjectByOIDFunc{
|
|
defaultHook: func(context.Context, int64, lfsutil.OID) (r0 *db.LFSObject, r1 error) {
|
|
return
|
|
},
|
|
},
|
|
GetObjectsByOIDsFunc: &LFSStoreGetObjectsByOIDsFunc{
|
|
defaultHook: func(context.Context, int64, ...lfsutil.OID) (r0 []*db.LFSObject, r1 error) {
|
|
return
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// NewStrictMockLFSStore creates a new mock of the LFSStore interface. All
|
|
// methods panic on invocation, unless overwritten.
|
|
func NewStrictMockLFSStore() *MockLFSStore {
|
|
return &MockLFSStore{
|
|
CreateObjectFunc: &LFSStoreCreateObjectFunc{
|
|
defaultHook: func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error {
|
|
panic("unexpected invocation of MockLFSStore.CreateObject")
|
|
},
|
|
},
|
|
GetObjectByOIDFunc: &LFSStoreGetObjectByOIDFunc{
|
|
defaultHook: func(context.Context, int64, lfsutil.OID) (*db.LFSObject, error) {
|
|
panic("unexpected invocation of MockLFSStore.GetObjectByOID")
|
|
},
|
|
},
|
|
GetObjectsByOIDsFunc: &LFSStoreGetObjectsByOIDsFunc{
|
|
defaultHook: func(context.Context, int64, ...lfsutil.OID) ([]*db.LFSObject, error) {
|
|
panic("unexpected invocation of MockLFSStore.GetObjectsByOIDs")
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// NewMockLFSStoreFrom creates a new mock of the MockLFSStore interface. All
|
|
// methods delegate to the given implementation, unless overwritten.
|
|
func NewMockLFSStoreFrom(i db.LFSStore) *MockLFSStore {
|
|
return &MockLFSStore{
|
|
CreateObjectFunc: &LFSStoreCreateObjectFunc{
|
|
defaultHook: i.CreateObject,
|
|
},
|
|
GetObjectByOIDFunc: &LFSStoreGetObjectByOIDFunc{
|
|
defaultHook: i.GetObjectByOID,
|
|
},
|
|
GetObjectsByOIDsFunc: &LFSStoreGetObjectsByOIDsFunc{
|
|
defaultHook: i.GetObjectsByOIDs,
|
|
},
|
|
}
|
|
}
|
|
|
|
// LFSStoreCreateObjectFunc describes the behavior when the CreateObject
|
|
// method of the parent MockLFSStore instance is invoked.
|
|
type LFSStoreCreateObjectFunc struct {
|
|
defaultHook func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error
|
|
hooks []func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error
|
|
history []LFSStoreCreateObjectFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// CreateObject delegates to the next hook function in the queue and stores
|
|
// the parameter and result values of this invocation.
|
|
func (m *MockLFSStore) CreateObject(v0 context.Context, v1 int64, v2 lfsutil.OID, v3 int64, v4 lfsutil.Storage) error {
|
|
r0 := m.CreateObjectFunc.nextHook()(v0, v1, v2, v3, v4)
|
|
m.CreateObjectFunc.appendCall(LFSStoreCreateObjectFuncCall{v0, v1, v2, v3, v4, r0})
|
|
return r0
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the CreateObject method
|
|
// of the parent MockLFSStore instance is invoked and the hook queue is
|
|
// empty.
|
|
func (f *LFSStoreCreateObjectFunc) SetDefaultHook(hook func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// CreateObject method of the parent MockLFSStore instance invokes the hook
|
|
// at the front of the queue and discards it. After the queue is empty, the
|
|
// default hook function is invoked for any future action.
|
|
func (f *LFSStoreCreateObjectFunc) PushHook(hook func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *LFSStoreCreateObjectFunc) SetDefaultReturn(r0 error) {
|
|
f.SetDefaultHook(func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *LFSStoreCreateObjectFunc) PushReturn(r0 error) {
|
|
f.PushHook(func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
func (f *LFSStoreCreateObjectFunc) nextHook() func(context.Context, int64, lfsutil.OID, int64, lfsutil.Storage) error {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *LFSStoreCreateObjectFunc) appendCall(r0 LFSStoreCreateObjectFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of LFSStoreCreateObjectFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *LFSStoreCreateObjectFunc) History() []LFSStoreCreateObjectFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]LFSStoreCreateObjectFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// LFSStoreCreateObjectFuncCall is an object that describes an invocation of
|
|
// method CreateObject on an instance of MockLFSStore.
|
|
type LFSStoreCreateObjectFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Arg2 is the value of the 3rd argument passed to this method
|
|
// invocation.
|
|
Arg2 lfsutil.OID
|
|
// Arg3 is the value of the 4th argument passed to this method
|
|
// invocation.
|
|
Arg3 int64
|
|
// Arg4 is the value of the 5th argument passed to this method
|
|
// invocation.
|
|
Arg4 lfsutil.Storage
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c LFSStoreCreateObjectFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1, c.Arg2, c.Arg3, c.Arg4}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c LFSStoreCreateObjectFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0}
|
|
}
|
|
|
|
// LFSStoreGetObjectByOIDFunc describes the behavior when the GetObjectByOID
|
|
// method of the parent MockLFSStore instance is invoked.
|
|
type LFSStoreGetObjectByOIDFunc struct {
|
|
defaultHook func(context.Context, int64, lfsutil.OID) (*db.LFSObject, error)
|
|
hooks []func(context.Context, int64, lfsutil.OID) (*db.LFSObject, error)
|
|
history []LFSStoreGetObjectByOIDFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// GetObjectByOID delegates to the next hook function in the queue and
|
|
// stores the parameter and result values of this invocation.
|
|
func (m *MockLFSStore) GetObjectByOID(v0 context.Context, v1 int64, v2 lfsutil.OID) (*db.LFSObject, error) {
|
|
r0, r1 := m.GetObjectByOIDFunc.nextHook()(v0, v1, v2)
|
|
m.GetObjectByOIDFunc.appendCall(LFSStoreGetObjectByOIDFuncCall{v0, v1, v2, r0, r1})
|
|
return r0, r1
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the GetObjectByOID
|
|
// method of the parent MockLFSStore instance is invoked and the hook queue
|
|
// is empty.
|
|
func (f *LFSStoreGetObjectByOIDFunc) SetDefaultHook(hook func(context.Context, int64, lfsutil.OID) (*db.LFSObject, error)) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// GetObjectByOID method of the parent MockLFSStore instance invokes the
|
|
// hook at the front of the queue and discards it. After the queue is empty,
|
|
// the default hook function is invoked for any future action.
|
|
func (f *LFSStoreGetObjectByOIDFunc) PushHook(hook func(context.Context, int64, lfsutil.OID) (*db.LFSObject, error)) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *LFSStoreGetObjectByOIDFunc) SetDefaultReturn(r0 *db.LFSObject, r1 error) {
|
|
f.SetDefaultHook(func(context.Context, int64, lfsutil.OID) (*db.LFSObject, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *LFSStoreGetObjectByOIDFunc) PushReturn(r0 *db.LFSObject, r1 error) {
|
|
f.PushHook(func(context.Context, int64, lfsutil.OID) (*db.LFSObject, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
func (f *LFSStoreGetObjectByOIDFunc) nextHook() func(context.Context, int64, lfsutil.OID) (*db.LFSObject, error) {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *LFSStoreGetObjectByOIDFunc) appendCall(r0 LFSStoreGetObjectByOIDFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of LFSStoreGetObjectByOIDFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *LFSStoreGetObjectByOIDFunc) History() []LFSStoreGetObjectByOIDFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]LFSStoreGetObjectByOIDFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// LFSStoreGetObjectByOIDFuncCall is an object that describes an invocation
|
|
// of method GetObjectByOID on an instance of MockLFSStore.
|
|
type LFSStoreGetObjectByOIDFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Arg2 is the value of the 3rd argument passed to this method
|
|
// invocation.
|
|
Arg2 lfsutil.OID
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 *db.LFSObject
|
|
// Result1 is the value of the 2nd result returned from this method
|
|
// invocation.
|
|
Result1 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c LFSStoreGetObjectByOIDFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1, c.Arg2}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c LFSStoreGetObjectByOIDFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0, c.Result1}
|
|
}
|
|
|
|
// LFSStoreGetObjectsByOIDsFunc describes the behavior when the
|
|
// GetObjectsByOIDs method of the parent MockLFSStore instance is invoked.
|
|
type LFSStoreGetObjectsByOIDsFunc struct {
|
|
defaultHook func(context.Context, int64, ...lfsutil.OID) ([]*db.LFSObject, error)
|
|
hooks []func(context.Context, int64, ...lfsutil.OID) ([]*db.LFSObject, error)
|
|
history []LFSStoreGetObjectsByOIDsFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// GetObjectsByOIDs delegates to the next hook function in the queue and
|
|
// stores the parameter and result values of this invocation.
|
|
func (m *MockLFSStore) GetObjectsByOIDs(v0 context.Context, v1 int64, v2 ...lfsutil.OID) ([]*db.LFSObject, error) {
|
|
r0, r1 := m.GetObjectsByOIDsFunc.nextHook()(v0, v1, v2...)
|
|
m.GetObjectsByOIDsFunc.appendCall(LFSStoreGetObjectsByOIDsFuncCall{v0, v1, v2, r0, r1})
|
|
return r0, r1
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the GetObjectsByOIDs
|
|
// method of the parent MockLFSStore instance is invoked and the hook queue
|
|
// is empty.
|
|
func (f *LFSStoreGetObjectsByOIDsFunc) SetDefaultHook(hook func(context.Context, int64, ...lfsutil.OID) ([]*db.LFSObject, error)) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// GetObjectsByOIDs method of the parent MockLFSStore instance invokes the
|
|
// hook at the front of the queue and discards it. After the queue is empty,
|
|
// the default hook function is invoked for any future action.
|
|
func (f *LFSStoreGetObjectsByOIDsFunc) PushHook(hook func(context.Context, int64, ...lfsutil.OID) ([]*db.LFSObject, error)) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *LFSStoreGetObjectsByOIDsFunc) SetDefaultReturn(r0 []*db.LFSObject, r1 error) {
|
|
f.SetDefaultHook(func(context.Context, int64, ...lfsutil.OID) ([]*db.LFSObject, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *LFSStoreGetObjectsByOIDsFunc) PushReturn(r0 []*db.LFSObject, r1 error) {
|
|
f.PushHook(func(context.Context, int64, ...lfsutil.OID) ([]*db.LFSObject, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
func (f *LFSStoreGetObjectsByOIDsFunc) nextHook() func(context.Context, int64, ...lfsutil.OID) ([]*db.LFSObject, error) {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *LFSStoreGetObjectsByOIDsFunc) appendCall(r0 LFSStoreGetObjectsByOIDsFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of LFSStoreGetObjectsByOIDsFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *LFSStoreGetObjectsByOIDsFunc) History() []LFSStoreGetObjectsByOIDsFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]LFSStoreGetObjectsByOIDsFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// LFSStoreGetObjectsByOIDsFuncCall is an object that describes an
|
|
// invocation of method GetObjectsByOIDs on an instance of MockLFSStore.
|
|
type LFSStoreGetObjectsByOIDsFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Arg2 is a slice containing the values of the variadic arguments
|
|
// passed to this method invocation.
|
|
Arg2 []lfsutil.OID
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 []*db.LFSObject
|
|
// Result1 is the value of the 2nd result returned from this method
|
|
// invocation.
|
|
Result1 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation. The variadic slice argument is flattened in this array such
|
|
// that one positional argument and three variadic arguments would result in
|
|
// a slice of four, not two.
|
|
func (c LFSStoreGetObjectsByOIDsFuncCall) Args() []interface{} {
|
|
trailing := []interface{}{}
|
|
for _, val := range c.Arg2 {
|
|
trailing = append(trailing, val)
|
|
}
|
|
|
|
return append([]interface{}{c.Arg0, c.Arg1}, trailing...)
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c LFSStoreGetObjectsByOIDsFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0, c.Result1}
|
|
}
|
|
|
|
// MockPermsStore is a mock implementation of the PermsStore interface (from
|
|
// the package gogs.io/gogs/internal/db) used for unit testing.
|
|
type MockPermsStore struct {
|
|
// AccessModeFunc is an instance of a mock function object controlling
|
|
// the behavior of the method AccessMode.
|
|
AccessModeFunc *PermsStoreAccessModeFunc
|
|
// AuthorizeFunc is an instance of a mock function object controlling
|
|
// the behavior of the method Authorize.
|
|
AuthorizeFunc *PermsStoreAuthorizeFunc
|
|
// SetRepoPermsFunc is an instance of a mock function object controlling
|
|
// the behavior of the method SetRepoPerms.
|
|
SetRepoPermsFunc *PermsStoreSetRepoPermsFunc
|
|
}
|
|
|
|
// NewMockPermsStore creates a new mock of the PermsStore interface. All
|
|
// methods return zero values for all results, unless overwritten.
|
|
func NewMockPermsStore() *MockPermsStore {
|
|
return &MockPermsStore{
|
|
AccessModeFunc: &PermsStoreAccessModeFunc{
|
|
defaultHook: func(context.Context, int64, int64, db.AccessModeOptions) (r0 db.AccessMode) {
|
|
return
|
|
},
|
|
},
|
|
AuthorizeFunc: &PermsStoreAuthorizeFunc{
|
|
defaultHook: func(context.Context, int64, int64, db.AccessMode, db.AccessModeOptions) (r0 bool) {
|
|
return
|
|
},
|
|
},
|
|
SetRepoPermsFunc: &PermsStoreSetRepoPermsFunc{
|
|
defaultHook: func(context.Context, int64, map[int64]db.AccessMode) (r0 error) {
|
|
return
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// NewStrictMockPermsStore creates a new mock of the PermsStore interface.
|
|
// All methods panic on invocation, unless overwritten.
|
|
func NewStrictMockPermsStore() *MockPermsStore {
|
|
return &MockPermsStore{
|
|
AccessModeFunc: &PermsStoreAccessModeFunc{
|
|
defaultHook: func(context.Context, int64, int64, db.AccessModeOptions) db.AccessMode {
|
|
panic("unexpected invocation of MockPermsStore.AccessMode")
|
|
},
|
|
},
|
|
AuthorizeFunc: &PermsStoreAuthorizeFunc{
|
|
defaultHook: func(context.Context, int64, int64, db.AccessMode, db.AccessModeOptions) bool {
|
|
panic("unexpected invocation of MockPermsStore.Authorize")
|
|
},
|
|
},
|
|
SetRepoPermsFunc: &PermsStoreSetRepoPermsFunc{
|
|
defaultHook: func(context.Context, int64, map[int64]db.AccessMode) error {
|
|
panic("unexpected invocation of MockPermsStore.SetRepoPerms")
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// NewMockPermsStoreFrom creates a new mock of the MockPermsStore interface.
|
|
// All methods delegate to the given implementation, unless overwritten.
|
|
func NewMockPermsStoreFrom(i db.PermsStore) *MockPermsStore {
|
|
return &MockPermsStore{
|
|
AccessModeFunc: &PermsStoreAccessModeFunc{
|
|
defaultHook: i.AccessMode,
|
|
},
|
|
AuthorizeFunc: &PermsStoreAuthorizeFunc{
|
|
defaultHook: i.Authorize,
|
|
},
|
|
SetRepoPermsFunc: &PermsStoreSetRepoPermsFunc{
|
|
defaultHook: i.SetRepoPerms,
|
|
},
|
|
}
|
|
}
|
|
|
|
// PermsStoreAccessModeFunc describes the behavior when the AccessMode
|
|
// method of the parent MockPermsStore instance is invoked.
|
|
type PermsStoreAccessModeFunc struct {
|
|
defaultHook func(context.Context, int64, int64, db.AccessModeOptions) db.AccessMode
|
|
hooks []func(context.Context, int64, int64, db.AccessModeOptions) db.AccessMode
|
|
history []PermsStoreAccessModeFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// AccessMode delegates to the next hook function in the queue and stores
|
|
// the parameter and result values of this invocation.
|
|
func (m *MockPermsStore) AccessMode(v0 context.Context, v1 int64, v2 int64, v3 db.AccessModeOptions) db.AccessMode {
|
|
r0 := m.AccessModeFunc.nextHook()(v0, v1, v2, v3)
|
|
m.AccessModeFunc.appendCall(PermsStoreAccessModeFuncCall{v0, v1, v2, v3, r0})
|
|
return r0
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the AccessMode method of
|
|
// the parent MockPermsStore instance is invoked and the hook queue is
|
|
// empty.
|
|
func (f *PermsStoreAccessModeFunc) SetDefaultHook(hook func(context.Context, int64, int64, db.AccessModeOptions) db.AccessMode) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// AccessMode method of the parent MockPermsStore instance invokes the hook
|
|
// at the front of the queue and discards it. After the queue is empty, the
|
|
// default hook function is invoked for any future action.
|
|
func (f *PermsStoreAccessModeFunc) PushHook(hook func(context.Context, int64, int64, db.AccessModeOptions) db.AccessMode) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *PermsStoreAccessModeFunc) SetDefaultReturn(r0 db.AccessMode) {
|
|
f.SetDefaultHook(func(context.Context, int64, int64, db.AccessModeOptions) db.AccessMode {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *PermsStoreAccessModeFunc) PushReturn(r0 db.AccessMode) {
|
|
f.PushHook(func(context.Context, int64, int64, db.AccessModeOptions) db.AccessMode {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
func (f *PermsStoreAccessModeFunc) nextHook() func(context.Context, int64, int64, db.AccessModeOptions) db.AccessMode {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *PermsStoreAccessModeFunc) appendCall(r0 PermsStoreAccessModeFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of PermsStoreAccessModeFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *PermsStoreAccessModeFunc) History() []PermsStoreAccessModeFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]PermsStoreAccessModeFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// PermsStoreAccessModeFuncCall is an object that describes an invocation of
|
|
// method AccessMode on an instance of MockPermsStore.
|
|
type PermsStoreAccessModeFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Arg2 is the value of the 3rd argument passed to this method
|
|
// invocation.
|
|
Arg2 int64
|
|
// Arg3 is the value of the 4th argument passed to this method
|
|
// invocation.
|
|
Arg3 db.AccessModeOptions
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 db.AccessMode
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c PermsStoreAccessModeFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1, c.Arg2, c.Arg3}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c PermsStoreAccessModeFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0}
|
|
}
|
|
|
|
// PermsStoreAuthorizeFunc describes the behavior when the Authorize method
|
|
// of the parent MockPermsStore instance is invoked.
|
|
type PermsStoreAuthorizeFunc struct {
|
|
defaultHook func(context.Context, int64, int64, db.AccessMode, db.AccessModeOptions) bool
|
|
hooks []func(context.Context, int64, int64, db.AccessMode, db.AccessModeOptions) bool
|
|
history []PermsStoreAuthorizeFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// Authorize delegates to the next hook function in the queue and stores the
|
|
// parameter and result values of this invocation.
|
|
func (m *MockPermsStore) Authorize(v0 context.Context, v1 int64, v2 int64, v3 db.AccessMode, v4 db.AccessModeOptions) bool {
|
|
r0 := m.AuthorizeFunc.nextHook()(v0, v1, v2, v3, v4)
|
|
m.AuthorizeFunc.appendCall(PermsStoreAuthorizeFuncCall{v0, v1, v2, v3, v4, r0})
|
|
return r0
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the Authorize method of
|
|
// the parent MockPermsStore instance is invoked and the hook queue is
|
|
// empty.
|
|
func (f *PermsStoreAuthorizeFunc) SetDefaultHook(hook func(context.Context, int64, int64, db.AccessMode, db.AccessModeOptions) bool) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// Authorize method of the parent MockPermsStore instance invokes the hook
|
|
// at the front of the queue and discards it. After the queue is empty, the
|
|
// default hook function is invoked for any future action.
|
|
func (f *PermsStoreAuthorizeFunc) PushHook(hook func(context.Context, int64, int64, db.AccessMode, db.AccessModeOptions) bool) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *PermsStoreAuthorizeFunc) SetDefaultReturn(r0 bool) {
|
|
f.SetDefaultHook(func(context.Context, int64, int64, db.AccessMode, db.AccessModeOptions) bool {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *PermsStoreAuthorizeFunc) PushReturn(r0 bool) {
|
|
f.PushHook(func(context.Context, int64, int64, db.AccessMode, db.AccessModeOptions) bool {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
func (f *PermsStoreAuthorizeFunc) nextHook() func(context.Context, int64, int64, db.AccessMode, db.AccessModeOptions) bool {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *PermsStoreAuthorizeFunc) appendCall(r0 PermsStoreAuthorizeFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of PermsStoreAuthorizeFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *PermsStoreAuthorizeFunc) History() []PermsStoreAuthorizeFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]PermsStoreAuthorizeFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// PermsStoreAuthorizeFuncCall is an object that describes an invocation of
|
|
// method Authorize on an instance of MockPermsStore.
|
|
type PermsStoreAuthorizeFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Arg2 is the value of the 3rd argument passed to this method
|
|
// invocation.
|
|
Arg2 int64
|
|
// Arg3 is the value of the 4th argument passed to this method
|
|
// invocation.
|
|
Arg3 db.AccessMode
|
|
// Arg4 is the value of the 5th argument passed to this method
|
|
// invocation.
|
|
Arg4 db.AccessModeOptions
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 bool
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c PermsStoreAuthorizeFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1, c.Arg2, c.Arg3, c.Arg4}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c PermsStoreAuthorizeFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0}
|
|
}
|
|
|
|
// PermsStoreSetRepoPermsFunc describes the behavior when the SetRepoPerms
|
|
// method of the parent MockPermsStore instance is invoked.
|
|
type PermsStoreSetRepoPermsFunc struct {
|
|
defaultHook func(context.Context, int64, map[int64]db.AccessMode) error
|
|
hooks []func(context.Context, int64, map[int64]db.AccessMode) error
|
|
history []PermsStoreSetRepoPermsFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// SetRepoPerms delegates to the next hook function in the queue and stores
|
|
// the parameter and result values of this invocation.
|
|
func (m *MockPermsStore) SetRepoPerms(v0 context.Context, v1 int64, v2 map[int64]db.AccessMode) error {
|
|
r0 := m.SetRepoPermsFunc.nextHook()(v0, v1, v2)
|
|
m.SetRepoPermsFunc.appendCall(PermsStoreSetRepoPermsFuncCall{v0, v1, v2, r0})
|
|
return r0
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the SetRepoPerms method
|
|
// of the parent MockPermsStore instance is invoked and the hook queue is
|
|
// empty.
|
|
func (f *PermsStoreSetRepoPermsFunc) SetDefaultHook(hook func(context.Context, int64, map[int64]db.AccessMode) error) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// SetRepoPerms method of the parent MockPermsStore instance invokes the
|
|
// hook at the front of the queue and discards it. After the queue is empty,
|
|
// the default hook function is invoked for any future action.
|
|
func (f *PermsStoreSetRepoPermsFunc) PushHook(hook func(context.Context, int64, map[int64]db.AccessMode) error) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *PermsStoreSetRepoPermsFunc) SetDefaultReturn(r0 error) {
|
|
f.SetDefaultHook(func(context.Context, int64, map[int64]db.AccessMode) error {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *PermsStoreSetRepoPermsFunc) PushReturn(r0 error) {
|
|
f.PushHook(func(context.Context, int64, map[int64]db.AccessMode) error {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
func (f *PermsStoreSetRepoPermsFunc) nextHook() func(context.Context, int64, map[int64]db.AccessMode) error {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *PermsStoreSetRepoPermsFunc) appendCall(r0 PermsStoreSetRepoPermsFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of PermsStoreSetRepoPermsFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *PermsStoreSetRepoPermsFunc) History() []PermsStoreSetRepoPermsFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]PermsStoreSetRepoPermsFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// PermsStoreSetRepoPermsFuncCall is an object that describes an invocation
|
|
// of method SetRepoPerms on an instance of MockPermsStore.
|
|
type PermsStoreSetRepoPermsFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Arg2 is the value of the 3rd argument passed to this method
|
|
// invocation.
|
|
Arg2 map[int64]db.AccessMode
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c PermsStoreSetRepoPermsFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1, c.Arg2}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c PermsStoreSetRepoPermsFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0}
|
|
}
|
|
|
|
// MockReposStore is a mock implementation of the ReposStore interface (from
|
|
// the package gogs.io/gogs/internal/db) used for unit testing.
|
|
type MockReposStore struct {
|
|
// CreateFunc is an instance of a mock function object controlling the
|
|
// behavior of the method Create.
|
|
CreateFunc *ReposStoreCreateFunc
|
|
// GetByNameFunc is an instance of a mock function object controlling
|
|
// the behavior of the method GetByName.
|
|
GetByNameFunc *ReposStoreGetByNameFunc
|
|
// TouchFunc is an instance of a mock function object controlling the
|
|
// behavior of the method Touch.
|
|
TouchFunc *ReposStoreTouchFunc
|
|
}
|
|
|
|
// NewMockReposStore creates a new mock of the ReposStore interface. All
|
|
// methods return zero values for all results, unless overwritten.
|
|
func NewMockReposStore() *MockReposStore {
|
|
return &MockReposStore{
|
|
CreateFunc: &ReposStoreCreateFunc{
|
|
defaultHook: func(context.Context, int64, db.CreateRepoOptions) (r0 *db.Repository, r1 error) {
|
|
return
|
|
},
|
|
},
|
|
GetByNameFunc: &ReposStoreGetByNameFunc{
|
|
defaultHook: func(context.Context, int64, string) (r0 *db.Repository, r1 error) {
|
|
return
|
|
},
|
|
},
|
|
TouchFunc: &ReposStoreTouchFunc{
|
|
defaultHook: func(context.Context, int64) (r0 error) {
|
|
return
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// NewStrictMockReposStore creates a new mock of the ReposStore interface.
|
|
// All methods panic on invocation, unless overwritten.
|
|
func NewStrictMockReposStore() *MockReposStore {
|
|
return &MockReposStore{
|
|
CreateFunc: &ReposStoreCreateFunc{
|
|
defaultHook: func(context.Context, int64, db.CreateRepoOptions) (*db.Repository, error) {
|
|
panic("unexpected invocation of MockReposStore.Create")
|
|
},
|
|
},
|
|
GetByNameFunc: &ReposStoreGetByNameFunc{
|
|
defaultHook: func(context.Context, int64, string) (*db.Repository, error) {
|
|
panic("unexpected invocation of MockReposStore.GetByName")
|
|
},
|
|
},
|
|
TouchFunc: &ReposStoreTouchFunc{
|
|
defaultHook: func(context.Context, int64) error {
|
|
panic("unexpected invocation of MockReposStore.Touch")
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// NewMockReposStoreFrom creates a new mock of the MockReposStore interface.
|
|
// All methods delegate to the given implementation, unless overwritten.
|
|
func NewMockReposStoreFrom(i db.ReposStore) *MockReposStore {
|
|
return &MockReposStore{
|
|
CreateFunc: &ReposStoreCreateFunc{
|
|
defaultHook: i.Create,
|
|
},
|
|
GetByNameFunc: &ReposStoreGetByNameFunc{
|
|
defaultHook: i.GetByName,
|
|
},
|
|
TouchFunc: &ReposStoreTouchFunc{
|
|
defaultHook: i.Touch,
|
|
},
|
|
}
|
|
}
|
|
|
|
// ReposStoreCreateFunc describes the behavior when the Create method of the
|
|
// parent MockReposStore instance is invoked.
|
|
type ReposStoreCreateFunc struct {
|
|
defaultHook func(context.Context, int64, db.CreateRepoOptions) (*db.Repository, error)
|
|
hooks []func(context.Context, int64, db.CreateRepoOptions) (*db.Repository, error)
|
|
history []ReposStoreCreateFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// Create delegates to the next hook function in the queue and stores the
|
|
// parameter and result values of this invocation.
|
|
func (m *MockReposStore) Create(v0 context.Context, v1 int64, v2 db.CreateRepoOptions) (*db.Repository, error) {
|
|
r0, r1 := m.CreateFunc.nextHook()(v0, v1, v2)
|
|
m.CreateFunc.appendCall(ReposStoreCreateFuncCall{v0, v1, v2, r0, r1})
|
|
return r0, r1
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the Create method of the
|
|
// parent MockReposStore instance is invoked and the hook queue is empty.
|
|
func (f *ReposStoreCreateFunc) SetDefaultHook(hook func(context.Context, int64, db.CreateRepoOptions) (*db.Repository, error)) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// Create method of the parent MockReposStore instance invokes the hook at
|
|
// the front of the queue and discards it. After the queue is empty, the
|
|
// default hook function is invoked for any future action.
|
|
func (f *ReposStoreCreateFunc) PushHook(hook func(context.Context, int64, db.CreateRepoOptions) (*db.Repository, error)) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *ReposStoreCreateFunc) SetDefaultReturn(r0 *db.Repository, r1 error) {
|
|
f.SetDefaultHook(func(context.Context, int64, db.CreateRepoOptions) (*db.Repository, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *ReposStoreCreateFunc) PushReturn(r0 *db.Repository, r1 error) {
|
|
f.PushHook(func(context.Context, int64, db.CreateRepoOptions) (*db.Repository, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
func (f *ReposStoreCreateFunc) nextHook() func(context.Context, int64, db.CreateRepoOptions) (*db.Repository, error) {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *ReposStoreCreateFunc) appendCall(r0 ReposStoreCreateFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of ReposStoreCreateFuncCall objects describing
|
|
// the invocations of this function.
|
|
func (f *ReposStoreCreateFunc) History() []ReposStoreCreateFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]ReposStoreCreateFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// ReposStoreCreateFuncCall is an object that describes an invocation of
|
|
// method Create on an instance of MockReposStore.
|
|
type ReposStoreCreateFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Arg2 is the value of the 3rd argument passed to this method
|
|
// invocation.
|
|
Arg2 db.CreateRepoOptions
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 *db.Repository
|
|
// Result1 is the value of the 2nd result returned from this method
|
|
// invocation.
|
|
Result1 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c ReposStoreCreateFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1, c.Arg2}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c ReposStoreCreateFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0, c.Result1}
|
|
}
|
|
|
|
// ReposStoreGetByNameFunc describes the behavior when the GetByName method
|
|
// of the parent MockReposStore instance is invoked.
|
|
type ReposStoreGetByNameFunc struct {
|
|
defaultHook func(context.Context, int64, string) (*db.Repository, error)
|
|
hooks []func(context.Context, int64, string) (*db.Repository, error)
|
|
history []ReposStoreGetByNameFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// GetByName delegates to the next hook function in the queue and stores the
|
|
// parameter and result values of this invocation.
|
|
func (m *MockReposStore) GetByName(v0 context.Context, v1 int64, v2 string) (*db.Repository, error) {
|
|
r0, r1 := m.GetByNameFunc.nextHook()(v0, v1, v2)
|
|
m.GetByNameFunc.appendCall(ReposStoreGetByNameFuncCall{v0, v1, v2, r0, r1})
|
|
return r0, r1
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the GetByName method of
|
|
// the parent MockReposStore instance is invoked and the hook queue is
|
|
// empty.
|
|
func (f *ReposStoreGetByNameFunc) SetDefaultHook(hook func(context.Context, int64, string) (*db.Repository, error)) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// GetByName method of the parent MockReposStore instance invokes the hook
|
|
// at the front of the queue and discards it. After the queue is empty, the
|
|
// default hook function is invoked for any future action.
|
|
func (f *ReposStoreGetByNameFunc) PushHook(hook func(context.Context, int64, string) (*db.Repository, error)) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *ReposStoreGetByNameFunc) SetDefaultReturn(r0 *db.Repository, r1 error) {
|
|
f.SetDefaultHook(func(context.Context, int64, string) (*db.Repository, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *ReposStoreGetByNameFunc) PushReturn(r0 *db.Repository, r1 error) {
|
|
f.PushHook(func(context.Context, int64, string) (*db.Repository, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
func (f *ReposStoreGetByNameFunc) nextHook() func(context.Context, int64, string) (*db.Repository, error) {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *ReposStoreGetByNameFunc) appendCall(r0 ReposStoreGetByNameFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of ReposStoreGetByNameFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *ReposStoreGetByNameFunc) History() []ReposStoreGetByNameFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]ReposStoreGetByNameFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// ReposStoreGetByNameFuncCall is an object that describes an invocation of
|
|
// method GetByName on an instance of MockReposStore.
|
|
type ReposStoreGetByNameFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Arg2 is the value of the 3rd argument passed to this method
|
|
// invocation.
|
|
Arg2 string
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 *db.Repository
|
|
// Result1 is the value of the 2nd result returned from this method
|
|
// invocation.
|
|
Result1 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c ReposStoreGetByNameFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1, c.Arg2}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c ReposStoreGetByNameFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0, c.Result1}
|
|
}
|
|
|
|
// ReposStoreTouchFunc describes the behavior when the Touch method of the
|
|
// parent MockReposStore instance is invoked.
|
|
type ReposStoreTouchFunc struct {
|
|
defaultHook func(context.Context, int64) error
|
|
hooks []func(context.Context, int64) error
|
|
history []ReposStoreTouchFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// Touch delegates to the next hook function in the queue and stores the
|
|
// parameter and result values of this invocation.
|
|
func (m *MockReposStore) Touch(v0 context.Context, v1 int64) error {
|
|
r0 := m.TouchFunc.nextHook()(v0, v1)
|
|
m.TouchFunc.appendCall(ReposStoreTouchFuncCall{v0, v1, r0})
|
|
return r0
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the Touch method of the
|
|
// parent MockReposStore instance is invoked and the hook queue is empty.
|
|
func (f *ReposStoreTouchFunc) SetDefaultHook(hook func(context.Context, int64) error) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// Touch method of the parent MockReposStore instance invokes the hook at
|
|
// the front of the queue and discards it. After the queue is empty, the
|
|
// default hook function is invoked for any future action.
|
|
func (f *ReposStoreTouchFunc) PushHook(hook func(context.Context, int64) error) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *ReposStoreTouchFunc) SetDefaultReturn(r0 error) {
|
|
f.SetDefaultHook(func(context.Context, int64) error {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *ReposStoreTouchFunc) PushReturn(r0 error) {
|
|
f.PushHook(func(context.Context, int64) error {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
func (f *ReposStoreTouchFunc) nextHook() func(context.Context, int64) error {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *ReposStoreTouchFunc) appendCall(r0 ReposStoreTouchFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of ReposStoreTouchFuncCall objects describing
|
|
// the invocations of this function.
|
|
func (f *ReposStoreTouchFunc) History() []ReposStoreTouchFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]ReposStoreTouchFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// ReposStoreTouchFuncCall is an object that describes an invocation of
|
|
// method Touch on an instance of MockReposStore.
|
|
type ReposStoreTouchFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c ReposStoreTouchFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c ReposStoreTouchFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0}
|
|
}
|
|
|
|
// MockTwoFactorsStore is a mock implementation of the TwoFactorsStore
|
|
// interface (from the package gogs.io/gogs/internal/db) used for unit
|
|
// testing.
|
|
type MockTwoFactorsStore struct {
|
|
// CreateFunc is an instance of a mock function object controlling the
|
|
// behavior of the method Create.
|
|
CreateFunc *TwoFactorsStoreCreateFunc
|
|
// GetByUserIDFunc is an instance of a mock function object controlling
|
|
// the behavior of the method GetByUserID.
|
|
GetByUserIDFunc *TwoFactorsStoreGetByUserIDFunc
|
|
// IsUserEnabledFunc is an instance of a mock function object
|
|
// controlling the behavior of the method IsUserEnabled.
|
|
IsUserEnabledFunc *TwoFactorsStoreIsUserEnabledFunc
|
|
}
|
|
|
|
// NewMockTwoFactorsStore creates a new mock of the TwoFactorsStore
|
|
// interface. All methods return zero values for all results, unless
|
|
// overwritten.
|
|
func NewMockTwoFactorsStore() *MockTwoFactorsStore {
|
|
return &MockTwoFactorsStore{
|
|
CreateFunc: &TwoFactorsStoreCreateFunc{
|
|
defaultHook: func(context.Context, int64, string, string) (r0 error) {
|
|
return
|
|
},
|
|
},
|
|
GetByUserIDFunc: &TwoFactorsStoreGetByUserIDFunc{
|
|
defaultHook: func(context.Context, int64) (r0 *db.TwoFactor, r1 error) {
|
|
return
|
|
},
|
|
},
|
|
IsUserEnabledFunc: &TwoFactorsStoreIsUserEnabledFunc{
|
|
defaultHook: func(context.Context, int64) (r0 bool) {
|
|
return
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// NewStrictMockTwoFactorsStore creates a new mock of the TwoFactorsStore
|
|
// interface. All methods panic on invocation, unless overwritten.
|
|
func NewStrictMockTwoFactorsStore() *MockTwoFactorsStore {
|
|
return &MockTwoFactorsStore{
|
|
CreateFunc: &TwoFactorsStoreCreateFunc{
|
|
defaultHook: func(context.Context, int64, string, string) error {
|
|
panic("unexpected invocation of MockTwoFactorsStore.Create")
|
|
},
|
|
},
|
|
GetByUserIDFunc: &TwoFactorsStoreGetByUserIDFunc{
|
|
defaultHook: func(context.Context, int64) (*db.TwoFactor, error) {
|
|
panic("unexpected invocation of MockTwoFactorsStore.GetByUserID")
|
|
},
|
|
},
|
|
IsUserEnabledFunc: &TwoFactorsStoreIsUserEnabledFunc{
|
|
defaultHook: func(context.Context, int64) bool {
|
|
panic("unexpected invocation of MockTwoFactorsStore.IsUserEnabled")
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// NewMockTwoFactorsStoreFrom creates a new mock of the MockTwoFactorsStore
|
|
// interface. All methods delegate to the given implementation, unless
|
|
// overwritten.
|
|
func NewMockTwoFactorsStoreFrom(i db.TwoFactorsStore) *MockTwoFactorsStore {
|
|
return &MockTwoFactorsStore{
|
|
CreateFunc: &TwoFactorsStoreCreateFunc{
|
|
defaultHook: i.Create,
|
|
},
|
|
GetByUserIDFunc: &TwoFactorsStoreGetByUserIDFunc{
|
|
defaultHook: i.GetByUserID,
|
|
},
|
|
IsUserEnabledFunc: &TwoFactorsStoreIsUserEnabledFunc{
|
|
defaultHook: i.IsUserEnabled,
|
|
},
|
|
}
|
|
}
|
|
|
|
// TwoFactorsStoreCreateFunc describes the behavior when the Create method
|
|
// of the parent MockTwoFactorsStore instance is invoked.
|
|
type TwoFactorsStoreCreateFunc struct {
|
|
defaultHook func(context.Context, int64, string, string) error
|
|
hooks []func(context.Context, int64, string, string) error
|
|
history []TwoFactorsStoreCreateFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// Create delegates to the next hook function in the queue and stores the
|
|
// parameter and result values of this invocation.
|
|
func (m *MockTwoFactorsStore) Create(v0 context.Context, v1 int64, v2 string, v3 string) error {
|
|
r0 := m.CreateFunc.nextHook()(v0, v1, v2, v3)
|
|
m.CreateFunc.appendCall(TwoFactorsStoreCreateFuncCall{v0, v1, v2, v3, r0})
|
|
return r0
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the Create method of the
|
|
// parent MockTwoFactorsStore instance is invoked and the hook queue is
|
|
// empty.
|
|
func (f *TwoFactorsStoreCreateFunc) SetDefaultHook(hook func(context.Context, int64, string, string) error) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// Create method of the parent MockTwoFactorsStore instance invokes the hook
|
|
// at the front of the queue and discards it. After the queue is empty, the
|
|
// default hook function is invoked for any future action.
|
|
func (f *TwoFactorsStoreCreateFunc) PushHook(hook func(context.Context, int64, string, string) error) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *TwoFactorsStoreCreateFunc) SetDefaultReturn(r0 error) {
|
|
f.SetDefaultHook(func(context.Context, int64, string, string) error {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *TwoFactorsStoreCreateFunc) PushReturn(r0 error) {
|
|
f.PushHook(func(context.Context, int64, string, string) error {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
func (f *TwoFactorsStoreCreateFunc) nextHook() func(context.Context, int64, string, string) error {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *TwoFactorsStoreCreateFunc) appendCall(r0 TwoFactorsStoreCreateFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of TwoFactorsStoreCreateFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *TwoFactorsStoreCreateFunc) History() []TwoFactorsStoreCreateFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]TwoFactorsStoreCreateFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// TwoFactorsStoreCreateFuncCall is an object that describes an invocation
|
|
// of method Create on an instance of MockTwoFactorsStore.
|
|
type TwoFactorsStoreCreateFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Arg2 is the value of the 3rd argument passed to this method
|
|
// invocation.
|
|
Arg2 string
|
|
// Arg3 is the value of the 4th argument passed to this method
|
|
// invocation.
|
|
Arg3 string
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c TwoFactorsStoreCreateFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1, c.Arg2, c.Arg3}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c TwoFactorsStoreCreateFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0}
|
|
}
|
|
|
|
// TwoFactorsStoreGetByUserIDFunc describes the behavior when the
|
|
// GetByUserID method of the parent MockTwoFactorsStore instance is invoked.
|
|
type TwoFactorsStoreGetByUserIDFunc struct {
|
|
defaultHook func(context.Context, int64) (*db.TwoFactor, error)
|
|
hooks []func(context.Context, int64) (*db.TwoFactor, error)
|
|
history []TwoFactorsStoreGetByUserIDFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// GetByUserID delegates to the next hook function in the queue and stores
|
|
// the parameter and result values of this invocation.
|
|
func (m *MockTwoFactorsStore) GetByUserID(v0 context.Context, v1 int64) (*db.TwoFactor, error) {
|
|
r0, r1 := m.GetByUserIDFunc.nextHook()(v0, v1)
|
|
m.GetByUserIDFunc.appendCall(TwoFactorsStoreGetByUserIDFuncCall{v0, v1, r0, r1})
|
|
return r0, r1
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the GetByUserID method
|
|
// of the parent MockTwoFactorsStore instance is invoked and the hook queue
|
|
// is empty.
|
|
func (f *TwoFactorsStoreGetByUserIDFunc) SetDefaultHook(hook func(context.Context, int64) (*db.TwoFactor, error)) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// GetByUserID method of the parent MockTwoFactorsStore instance invokes the
|
|
// hook at the front of the queue and discards it. After the queue is empty,
|
|
// the default hook function is invoked for any future action.
|
|
func (f *TwoFactorsStoreGetByUserIDFunc) PushHook(hook func(context.Context, int64) (*db.TwoFactor, error)) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *TwoFactorsStoreGetByUserIDFunc) SetDefaultReturn(r0 *db.TwoFactor, r1 error) {
|
|
f.SetDefaultHook(func(context.Context, int64) (*db.TwoFactor, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *TwoFactorsStoreGetByUserIDFunc) PushReturn(r0 *db.TwoFactor, r1 error) {
|
|
f.PushHook(func(context.Context, int64) (*db.TwoFactor, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
func (f *TwoFactorsStoreGetByUserIDFunc) nextHook() func(context.Context, int64) (*db.TwoFactor, error) {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *TwoFactorsStoreGetByUserIDFunc) appendCall(r0 TwoFactorsStoreGetByUserIDFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of TwoFactorsStoreGetByUserIDFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *TwoFactorsStoreGetByUserIDFunc) History() []TwoFactorsStoreGetByUserIDFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]TwoFactorsStoreGetByUserIDFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// TwoFactorsStoreGetByUserIDFuncCall is an object that describes an
|
|
// invocation of method GetByUserID on an instance of MockTwoFactorsStore.
|
|
type TwoFactorsStoreGetByUserIDFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 *db.TwoFactor
|
|
// Result1 is the value of the 2nd result returned from this method
|
|
// invocation.
|
|
Result1 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c TwoFactorsStoreGetByUserIDFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c TwoFactorsStoreGetByUserIDFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0, c.Result1}
|
|
}
|
|
|
|
// TwoFactorsStoreIsUserEnabledFunc describes the behavior when the
|
|
// IsUserEnabled method of the parent MockTwoFactorsStore instance is
|
|
// invoked.
|
|
type TwoFactorsStoreIsUserEnabledFunc struct {
|
|
defaultHook func(context.Context, int64) bool
|
|
hooks []func(context.Context, int64) bool
|
|
history []TwoFactorsStoreIsUserEnabledFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// IsUserEnabled delegates to the next hook function in the queue and stores
|
|
// the parameter and result values of this invocation.
|
|
func (m *MockTwoFactorsStore) IsUserEnabled(v0 context.Context, v1 int64) bool {
|
|
r0 := m.IsUserEnabledFunc.nextHook()(v0, v1)
|
|
m.IsUserEnabledFunc.appendCall(TwoFactorsStoreIsUserEnabledFuncCall{v0, v1, r0})
|
|
return r0
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the IsUserEnabled method
|
|
// of the parent MockTwoFactorsStore instance is invoked and the hook queue
|
|
// is empty.
|
|
func (f *TwoFactorsStoreIsUserEnabledFunc) SetDefaultHook(hook func(context.Context, int64) bool) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// IsUserEnabled method of the parent MockTwoFactorsStore instance invokes
|
|
// the hook at the front of the queue and discards it. After the queue is
|
|
// empty, the default hook function is invoked for any future action.
|
|
func (f *TwoFactorsStoreIsUserEnabledFunc) PushHook(hook func(context.Context, int64) bool) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *TwoFactorsStoreIsUserEnabledFunc) SetDefaultReturn(r0 bool) {
|
|
f.SetDefaultHook(func(context.Context, int64) bool {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *TwoFactorsStoreIsUserEnabledFunc) PushReturn(r0 bool) {
|
|
f.PushHook(func(context.Context, int64) bool {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
func (f *TwoFactorsStoreIsUserEnabledFunc) nextHook() func(context.Context, int64) bool {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *TwoFactorsStoreIsUserEnabledFunc) appendCall(r0 TwoFactorsStoreIsUserEnabledFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of TwoFactorsStoreIsUserEnabledFuncCall
|
|
// objects describing the invocations of this function.
|
|
func (f *TwoFactorsStoreIsUserEnabledFunc) History() []TwoFactorsStoreIsUserEnabledFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]TwoFactorsStoreIsUserEnabledFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// TwoFactorsStoreIsUserEnabledFuncCall is an object that describes an
|
|
// invocation of method IsUserEnabled on an instance of MockTwoFactorsStore.
|
|
type TwoFactorsStoreIsUserEnabledFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 bool
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c TwoFactorsStoreIsUserEnabledFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c TwoFactorsStoreIsUserEnabledFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0}
|
|
}
|
|
|
|
// MockUsersStore is a mock implementation of the UsersStore interface (from
|
|
// the package gogs.io/gogs/internal/db) used for unit testing.
|
|
type MockUsersStore struct {
|
|
// AuthenticateFunc is an instance of a mock function object controlling
|
|
// the behavior of the method Authenticate.
|
|
AuthenticateFunc *UsersStoreAuthenticateFunc
|
|
// CreateFunc is an instance of a mock function object controlling the
|
|
// behavior of the method Create.
|
|
CreateFunc *UsersStoreCreateFunc
|
|
// GetByEmailFunc is an instance of a mock function object controlling
|
|
// the behavior of the method GetByEmail.
|
|
GetByEmailFunc *UsersStoreGetByEmailFunc
|
|
// GetByIDFunc is an instance of a mock function object controlling the
|
|
// behavior of the method GetByID.
|
|
GetByIDFunc *UsersStoreGetByIDFunc
|
|
// GetByUsernameFunc is an instance of a mock function object
|
|
// controlling the behavior of the method GetByUsername.
|
|
GetByUsernameFunc *UsersStoreGetByUsernameFunc
|
|
// HasForkedRepositoryFunc is an instance of a mock function object
|
|
// controlling the behavior of the method HasForkedRepository.
|
|
HasForkedRepositoryFunc *UsersStoreHasForkedRepositoryFunc
|
|
}
|
|
|
|
// NewMockUsersStore creates a new mock of the UsersStore interface. All
|
|
// methods return zero values for all results, unless overwritten.
|
|
func NewMockUsersStore() *MockUsersStore {
|
|
return &MockUsersStore{
|
|
AuthenticateFunc: &UsersStoreAuthenticateFunc{
|
|
defaultHook: func(context.Context, string, string, int64) (r0 *db.User, r1 error) {
|
|
return
|
|
},
|
|
},
|
|
CreateFunc: &UsersStoreCreateFunc{
|
|
defaultHook: func(context.Context, string, string, db.CreateUserOptions) (r0 *db.User, r1 error) {
|
|
return
|
|
},
|
|
},
|
|
GetByEmailFunc: &UsersStoreGetByEmailFunc{
|
|
defaultHook: func(context.Context, string) (r0 *db.User, r1 error) {
|
|
return
|
|
},
|
|
},
|
|
GetByIDFunc: &UsersStoreGetByIDFunc{
|
|
defaultHook: func(context.Context, int64) (r0 *db.User, r1 error) {
|
|
return
|
|
},
|
|
},
|
|
GetByUsernameFunc: &UsersStoreGetByUsernameFunc{
|
|
defaultHook: func(context.Context, string) (r0 *db.User, r1 error) {
|
|
return
|
|
},
|
|
},
|
|
HasForkedRepositoryFunc: &UsersStoreHasForkedRepositoryFunc{
|
|
defaultHook: func(context.Context, int64, int64) (r0 bool) {
|
|
return
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// NewStrictMockUsersStore creates a new mock of the UsersStore interface.
|
|
// All methods panic on invocation, unless overwritten.
|
|
func NewStrictMockUsersStore() *MockUsersStore {
|
|
return &MockUsersStore{
|
|
AuthenticateFunc: &UsersStoreAuthenticateFunc{
|
|
defaultHook: func(context.Context, string, string, int64) (*db.User, error) {
|
|
panic("unexpected invocation of MockUsersStore.Authenticate")
|
|
},
|
|
},
|
|
CreateFunc: &UsersStoreCreateFunc{
|
|
defaultHook: func(context.Context, string, string, db.CreateUserOptions) (*db.User, error) {
|
|
panic("unexpected invocation of MockUsersStore.Create")
|
|
},
|
|
},
|
|
GetByEmailFunc: &UsersStoreGetByEmailFunc{
|
|
defaultHook: func(context.Context, string) (*db.User, error) {
|
|
panic("unexpected invocation of MockUsersStore.GetByEmail")
|
|
},
|
|
},
|
|
GetByIDFunc: &UsersStoreGetByIDFunc{
|
|
defaultHook: func(context.Context, int64) (*db.User, error) {
|
|
panic("unexpected invocation of MockUsersStore.GetByID")
|
|
},
|
|
},
|
|
GetByUsernameFunc: &UsersStoreGetByUsernameFunc{
|
|
defaultHook: func(context.Context, string) (*db.User, error) {
|
|
panic("unexpected invocation of MockUsersStore.GetByUsername")
|
|
},
|
|
},
|
|
HasForkedRepositoryFunc: &UsersStoreHasForkedRepositoryFunc{
|
|
defaultHook: func(context.Context, int64, int64) bool {
|
|
panic("unexpected invocation of MockUsersStore.HasForkedRepository")
|
|
},
|
|
},
|
|
}
|
|
}
|
|
|
|
// NewMockUsersStoreFrom creates a new mock of the MockUsersStore interface.
|
|
// All methods delegate to the given implementation, unless overwritten.
|
|
func NewMockUsersStoreFrom(i db.UsersStore) *MockUsersStore {
|
|
return &MockUsersStore{
|
|
AuthenticateFunc: &UsersStoreAuthenticateFunc{
|
|
defaultHook: i.Authenticate,
|
|
},
|
|
CreateFunc: &UsersStoreCreateFunc{
|
|
defaultHook: i.Create,
|
|
},
|
|
GetByEmailFunc: &UsersStoreGetByEmailFunc{
|
|
defaultHook: i.GetByEmail,
|
|
},
|
|
GetByIDFunc: &UsersStoreGetByIDFunc{
|
|
defaultHook: i.GetByID,
|
|
},
|
|
GetByUsernameFunc: &UsersStoreGetByUsernameFunc{
|
|
defaultHook: i.GetByUsername,
|
|
},
|
|
HasForkedRepositoryFunc: &UsersStoreHasForkedRepositoryFunc{
|
|
defaultHook: i.HasForkedRepository,
|
|
},
|
|
}
|
|
}
|
|
|
|
// UsersStoreAuthenticateFunc describes the behavior when the Authenticate
|
|
// method of the parent MockUsersStore instance is invoked.
|
|
type UsersStoreAuthenticateFunc struct {
|
|
defaultHook func(context.Context, string, string, int64) (*db.User, error)
|
|
hooks []func(context.Context, string, string, int64) (*db.User, error)
|
|
history []UsersStoreAuthenticateFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// Authenticate delegates to the next hook function in the queue and stores
|
|
// the parameter and result values of this invocation.
|
|
func (m *MockUsersStore) Authenticate(v0 context.Context, v1 string, v2 string, v3 int64) (*db.User, error) {
|
|
r0, r1 := m.AuthenticateFunc.nextHook()(v0, v1, v2, v3)
|
|
m.AuthenticateFunc.appendCall(UsersStoreAuthenticateFuncCall{v0, v1, v2, v3, r0, r1})
|
|
return r0, r1
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the Authenticate method
|
|
// of the parent MockUsersStore instance is invoked and the hook queue is
|
|
// empty.
|
|
func (f *UsersStoreAuthenticateFunc) SetDefaultHook(hook func(context.Context, string, string, int64) (*db.User, error)) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// Authenticate method of the parent MockUsersStore instance invokes the
|
|
// hook at the front of the queue and discards it. After the queue is empty,
|
|
// the default hook function is invoked for any future action.
|
|
func (f *UsersStoreAuthenticateFunc) PushHook(hook func(context.Context, string, string, int64) (*db.User, error)) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *UsersStoreAuthenticateFunc) SetDefaultReturn(r0 *db.User, r1 error) {
|
|
f.SetDefaultHook(func(context.Context, string, string, int64) (*db.User, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *UsersStoreAuthenticateFunc) PushReturn(r0 *db.User, r1 error) {
|
|
f.PushHook(func(context.Context, string, string, int64) (*db.User, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
func (f *UsersStoreAuthenticateFunc) nextHook() func(context.Context, string, string, int64) (*db.User, error) {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *UsersStoreAuthenticateFunc) appendCall(r0 UsersStoreAuthenticateFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of UsersStoreAuthenticateFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *UsersStoreAuthenticateFunc) History() []UsersStoreAuthenticateFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]UsersStoreAuthenticateFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// UsersStoreAuthenticateFuncCall is an object that describes an invocation
|
|
// of method Authenticate on an instance of MockUsersStore.
|
|
type UsersStoreAuthenticateFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 string
|
|
// Arg2 is the value of the 3rd argument passed to this method
|
|
// invocation.
|
|
Arg2 string
|
|
// Arg3 is the value of the 4th argument passed to this method
|
|
// invocation.
|
|
Arg3 int64
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 *db.User
|
|
// Result1 is the value of the 2nd result returned from this method
|
|
// invocation.
|
|
Result1 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c UsersStoreAuthenticateFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1, c.Arg2, c.Arg3}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c UsersStoreAuthenticateFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0, c.Result1}
|
|
}
|
|
|
|
// UsersStoreCreateFunc describes the behavior when the Create method of the
|
|
// parent MockUsersStore instance is invoked.
|
|
type UsersStoreCreateFunc struct {
|
|
defaultHook func(context.Context, string, string, db.CreateUserOptions) (*db.User, error)
|
|
hooks []func(context.Context, string, string, db.CreateUserOptions) (*db.User, error)
|
|
history []UsersStoreCreateFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// Create delegates to the next hook function in the queue and stores the
|
|
// parameter and result values of this invocation.
|
|
func (m *MockUsersStore) Create(v0 context.Context, v1 string, v2 string, v3 db.CreateUserOptions) (*db.User, error) {
|
|
r0, r1 := m.CreateFunc.nextHook()(v0, v1, v2, v3)
|
|
m.CreateFunc.appendCall(UsersStoreCreateFuncCall{v0, v1, v2, v3, r0, r1})
|
|
return r0, r1
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the Create method of the
|
|
// parent MockUsersStore instance is invoked and the hook queue is empty.
|
|
func (f *UsersStoreCreateFunc) SetDefaultHook(hook func(context.Context, string, string, db.CreateUserOptions) (*db.User, error)) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// Create method of the parent MockUsersStore instance invokes the hook at
|
|
// the front of the queue and discards it. After the queue is empty, the
|
|
// default hook function is invoked for any future action.
|
|
func (f *UsersStoreCreateFunc) PushHook(hook func(context.Context, string, string, db.CreateUserOptions) (*db.User, error)) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *UsersStoreCreateFunc) SetDefaultReturn(r0 *db.User, r1 error) {
|
|
f.SetDefaultHook(func(context.Context, string, string, db.CreateUserOptions) (*db.User, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *UsersStoreCreateFunc) PushReturn(r0 *db.User, r1 error) {
|
|
f.PushHook(func(context.Context, string, string, db.CreateUserOptions) (*db.User, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
func (f *UsersStoreCreateFunc) nextHook() func(context.Context, string, string, db.CreateUserOptions) (*db.User, error) {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *UsersStoreCreateFunc) appendCall(r0 UsersStoreCreateFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of UsersStoreCreateFuncCall objects describing
|
|
// the invocations of this function.
|
|
func (f *UsersStoreCreateFunc) History() []UsersStoreCreateFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]UsersStoreCreateFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// UsersStoreCreateFuncCall is an object that describes an invocation of
|
|
// method Create on an instance of MockUsersStore.
|
|
type UsersStoreCreateFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 string
|
|
// Arg2 is the value of the 3rd argument passed to this method
|
|
// invocation.
|
|
Arg2 string
|
|
// Arg3 is the value of the 4th argument passed to this method
|
|
// invocation.
|
|
Arg3 db.CreateUserOptions
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 *db.User
|
|
// Result1 is the value of the 2nd result returned from this method
|
|
// invocation.
|
|
Result1 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c UsersStoreCreateFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1, c.Arg2, c.Arg3}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c UsersStoreCreateFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0, c.Result1}
|
|
}
|
|
|
|
// UsersStoreGetByEmailFunc describes the behavior when the GetByEmail
|
|
// method of the parent MockUsersStore instance is invoked.
|
|
type UsersStoreGetByEmailFunc struct {
|
|
defaultHook func(context.Context, string) (*db.User, error)
|
|
hooks []func(context.Context, string) (*db.User, error)
|
|
history []UsersStoreGetByEmailFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// GetByEmail delegates to the next hook function in the queue and stores
|
|
// the parameter and result values of this invocation.
|
|
func (m *MockUsersStore) GetByEmail(v0 context.Context, v1 string) (*db.User, error) {
|
|
r0, r1 := m.GetByEmailFunc.nextHook()(v0, v1)
|
|
m.GetByEmailFunc.appendCall(UsersStoreGetByEmailFuncCall{v0, v1, r0, r1})
|
|
return r0, r1
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the GetByEmail method of
|
|
// the parent MockUsersStore instance is invoked and the hook queue is
|
|
// empty.
|
|
func (f *UsersStoreGetByEmailFunc) SetDefaultHook(hook func(context.Context, string) (*db.User, error)) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// GetByEmail method of the parent MockUsersStore instance invokes the hook
|
|
// at the front of the queue and discards it. After the queue is empty, the
|
|
// default hook function is invoked for any future action.
|
|
func (f *UsersStoreGetByEmailFunc) PushHook(hook func(context.Context, string) (*db.User, error)) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *UsersStoreGetByEmailFunc) SetDefaultReturn(r0 *db.User, r1 error) {
|
|
f.SetDefaultHook(func(context.Context, string) (*db.User, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *UsersStoreGetByEmailFunc) PushReturn(r0 *db.User, r1 error) {
|
|
f.PushHook(func(context.Context, string) (*db.User, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
func (f *UsersStoreGetByEmailFunc) nextHook() func(context.Context, string) (*db.User, error) {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *UsersStoreGetByEmailFunc) appendCall(r0 UsersStoreGetByEmailFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of UsersStoreGetByEmailFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *UsersStoreGetByEmailFunc) History() []UsersStoreGetByEmailFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]UsersStoreGetByEmailFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// UsersStoreGetByEmailFuncCall is an object that describes an invocation of
|
|
// method GetByEmail on an instance of MockUsersStore.
|
|
type UsersStoreGetByEmailFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 string
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 *db.User
|
|
// Result1 is the value of the 2nd result returned from this method
|
|
// invocation.
|
|
Result1 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c UsersStoreGetByEmailFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c UsersStoreGetByEmailFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0, c.Result1}
|
|
}
|
|
|
|
// UsersStoreGetByIDFunc describes the behavior when the GetByID method of
|
|
// the parent MockUsersStore instance is invoked.
|
|
type UsersStoreGetByIDFunc struct {
|
|
defaultHook func(context.Context, int64) (*db.User, error)
|
|
hooks []func(context.Context, int64) (*db.User, error)
|
|
history []UsersStoreGetByIDFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// GetByID delegates to the next hook function in the queue and stores the
|
|
// parameter and result values of this invocation.
|
|
func (m *MockUsersStore) GetByID(v0 context.Context, v1 int64) (*db.User, error) {
|
|
r0, r1 := m.GetByIDFunc.nextHook()(v0, v1)
|
|
m.GetByIDFunc.appendCall(UsersStoreGetByIDFuncCall{v0, v1, r0, r1})
|
|
return r0, r1
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the GetByID method of
|
|
// the parent MockUsersStore instance is invoked and the hook queue is
|
|
// empty.
|
|
func (f *UsersStoreGetByIDFunc) SetDefaultHook(hook func(context.Context, int64) (*db.User, error)) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// GetByID method of the parent MockUsersStore instance invokes the hook at
|
|
// the front of the queue and discards it. After the queue is empty, the
|
|
// default hook function is invoked for any future action.
|
|
func (f *UsersStoreGetByIDFunc) PushHook(hook func(context.Context, int64) (*db.User, error)) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *UsersStoreGetByIDFunc) SetDefaultReturn(r0 *db.User, r1 error) {
|
|
f.SetDefaultHook(func(context.Context, int64) (*db.User, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *UsersStoreGetByIDFunc) PushReturn(r0 *db.User, r1 error) {
|
|
f.PushHook(func(context.Context, int64) (*db.User, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
func (f *UsersStoreGetByIDFunc) nextHook() func(context.Context, int64) (*db.User, error) {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *UsersStoreGetByIDFunc) appendCall(r0 UsersStoreGetByIDFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of UsersStoreGetByIDFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *UsersStoreGetByIDFunc) History() []UsersStoreGetByIDFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]UsersStoreGetByIDFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// UsersStoreGetByIDFuncCall is an object that describes an invocation of
|
|
// method GetByID on an instance of MockUsersStore.
|
|
type UsersStoreGetByIDFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 *db.User
|
|
// Result1 is the value of the 2nd result returned from this method
|
|
// invocation.
|
|
Result1 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c UsersStoreGetByIDFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c UsersStoreGetByIDFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0, c.Result1}
|
|
}
|
|
|
|
// UsersStoreGetByUsernameFunc describes the behavior when the GetByUsername
|
|
// method of the parent MockUsersStore instance is invoked.
|
|
type UsersStoreGetByUsernameFunc struct {
|
|
defaultHook func(context.Context, string) (*db.User, error)
|
|
hooks []func(context.Context, string) (*db.User, error)
|
|
history []UsersStoreGetByUsernameFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// GetByUsername delegates to the next hook function in the queue and stores
|
|
// the parameter and result values of this invocation.
|
|
func (m *MockUsersStore) GetByUsername(v0 context.Context, v1 string) (*db.User, error) {
|
|
r0, r1 := m.GetByUsernameFunc.nextHook()(v0, v1)
|
|
m.GetByUsernameFunc.appendCall(UsersStoreGetByUsernameFuncCall{v0, v1, r0, r1})
|
|
return r0, r1
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the GetByUsername method
|
|
// of the parent MockUsersStore instance is invoked and the hook queue is
|
|
// empty.
|
|
func (f *UsersStoreGetByUsernameFunc) SetDefaultHook(hook func(context.Context, string) (*db.User, error)) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// GetByUsername method of the parent MockUsersStore instance invokes the
|
|
// hook at the front of the queue and discards it. After the queue is empty,
|
|
// the default hook function is invoked for any future action.
|
|
func (f *UsersStoreGetByUsernameFunc) PushHook(hook func(context.Context, string) (*db.User, error)) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *UsersStoreGetByUsernameFunc) SetDefaultReturn(r0 *db.User, r1 error) {
|
|
f.SetDefaultHook(func(context.Context, string) (*db.User, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *UsersStoreGetByUsernameFunc) PushReturn(r0 *db.User, r1 error) {
|
|
f.PushHook(func(context.Context, string) (*db.User, error) {
|
|
return r0, r1
|
|
})
|
|
}
|
|
|
|
func (f *UsersStoreGetByUsernameFunc) nextHook() func(context.Context, string) (*db.User, error) {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *UsersStoreGetByUsernameFunc) appendCall(r0 UsersStoreGetByUsernameFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of UsersStoreGetByUsernameFuncCall objects
|
|
// describing the invocations of this function.
|
|
func (f *UsersStoreGetByUsernameFunc) History() []UsersStoreGetByUsernameFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]UsersStoreGetByUsernameFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// UsersStoreGetByUsernameFuncCall is an object that describes an invocation
|
|
// of method GetByUsername on an instance of MockUsersStore.
|
|
type UsersStoreGetByUsernameFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 string
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 *db.User
|
|
// Result1 is the value of the 2nd result returned from this method
|
|
// invocation.
|
|
Result1 error
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c UsersStoreGetByUsernameFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c UsersStoreGetByUsernameFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0, c.Result1}
|
|
}
|
|
|
|
// UsersStoreHasForkedRepositoryFunc describes the behavior when the
|
|
// HasForkedRepository method of the parent MockUsersStore instance is
|
|
// invoked.
|
|
type UsersStoreHasForkedRepositoryFunc struct {
|
|
defaultHook func(context.Context, int64, int64) bool
|
|
hooks []func(context.Context, int64, int64) bool
|
|
history []UsersStoreHasForkedRepositoryFuncCall
|
|
mutex sync.Mutex
|
|
}
|
|
|
|
// HasForkedRepository delegates to the next hook function in the queue and
|
|
// stores the parameter and result values of this invocation.
|
|
func (m *MockUsersStore) HasForkedRepository(v0 context.Context, v1 int64, v2 int64) bool {
|
|
r0 := m.HasForkedRepositoryFunc.nextHook()(v0, v1, v2)
|
|
m.HasForkedRepositoryFunc.appendCall(UsersStoreHasForkedRepositoryFuncCall{v0, v1, v2, r0})
|
|
return r0
|
|
}
|
|
|
|
// SetDefaultHook sets function that is called when the HasForkedRepository
|
|
// method of the parent MockUsersStore instance is invoked and the hook
|
|
// queue is empty.
|
|
func (f *UsersStoreHasForkedRepositoryFunc) SetDefaultHook(hook func(context.Context, int64, int64) bool) {
|
|
f.defaultHook = hook
|
|
}
|
|
|
|
// PushHook adds a function to the end of hook queue. Each invocation of the
|
|
// HasForkedRepository method of the parent MockUsersStore instance invokes
|
|
// the hook at the front of the queue and discards it. After the queue is
|
|
// empty, the default hook function is invoked for any future action.
|
|
func (f *UsersStoreHasForkedRepositoryFunc) PushHook(hook func(context.Context, int64, int64) bool) {
|
|
f.mutex.Lock()
|
|
f.hooks = append(f.hooks, hook)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// SetDefaultReturn calls SetDefaultHook with a function that returns the
|
|
// given values.
|
|
func (f *UsersStoreHasForkedRepositoryFunc) SetDefaultReturn(r0 bool) {
|
|
f.SetDefaultHook(func(context.Context, int64, int64) bool {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
// PushReturn calls PushHook with a function that returns the given values.
|
|
func (f *UsersStoreHasForkedRepositoryFunc) PushReturn(r0 bool) {
|
|
f.PushHook(func(context.Context, int64, int64) bool {
|
|
return r0
|
|
})
|
|
}
|
|
|
|
func (f *UsersStoreHasForkedRepositoryFunc) nextHook() func(context.Context, int64, int64) bool {
|
|
f.mutex.Lock()
|
|
defer f.mutex.Unlock()
|
|
|
|
if len(f.hooks) == 0 {
|
|
return f.defaultHook
|
|
}
|
|
|
|
hook := f.hooks[0]
|
|
f.hooks = f.hooks[1:]
|
|
return hook
|
|
}
|
|
|
|
func (f *UsersStoreHasForkedRepositoryFunc) appendCall(r0 UsersStoreHasForkedRepositoryFuncCall) {
|
|
f.mutex.Lock()
|
|
f.history = append(f.history, r0)
|
|
f.mutex.Unlock()
|
|
}
|
|
|
|
// History returns a sequence of UsersStoreHasForkedRepositoryFuncCall
|
|
// objects describing the invocations of this function.
|
|
func (f *UsersStoreHasForkedRepositoryFunc) History() []UsersStoreHasForkedRepositoryFuncCall {
|
|
f.mutex.Lock()
|
|
history := make([]UsersStoreHasForkedRepositoryFuncCall, len(f.history))
|
|
copy(history, f.history)
|
|
f.mutex.Unlock()
|
|
|
|
return history
|
|
}
|
|
|
|
// UsersStoreHasForkedRepositoryFuncCall is an object that describes an
|
|
// invocation of method HasForkedRepository on an instance of
|
|
// MockUsersStore.
|
|
type UsersStoreHasForkedRepositoryFuncCall struct {
|
|
// Arg0 is the value of the 1st argument passed to this method
|
|
// invocation.
|
|
Arg0 context.Context
|
|
// Arg1 is the value of the 2nd argument passed to this method
|
|
// invocation.
|
|
Arg1 int64
|
|
// Arg2 is the value of the 3rd argument passed to this method
|
|
// invocation.
|
|
Arg2 int64
|
|
// Result0 is the value of the 1st result returned from this method
|
|
// invocation.
|
|
Result0 bool
|
|
}
|
|
|
|
// Args returns an interface slice containing the arguments of this
|
|
// invocation.
|
|
func (c UsersStoreHasForkedRepositoryFuncCall) Args() []interface{} {
|
|
return []interface{}{c.Arg0, c.Arg1, c.Arg2}
|
|
}
|
|
|
|
// Results returns an interface slice containing the results of this
|
|
// invocation.
|
|
func (c UsersStoreHasForkedRepositoryFuncCall) Results() []interface{} {
|
|
return []interface{}{c.Result0}
|
|
}
|