From 9776bdc9b8b441ebd73c100bfe2aa4e495c233ca Mon Sep 17 00:00:00 2001 From: Joe Chen Date: Fri, 10 Jun 2022 19:54:36 +0800 Subject: db: use `context` and go-mockgen for login sources (#7041) --- internal/db/mocks.go | 2132 ++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 1961 insertions(+), 171 deletions(-) (limited to 'internal/db/mocks.go') diff --git a/internal/db/mocks.go b/internal/db/mocks.go index e5a24d06..87f3c2c3 100644 --- a/internal/db/mocks.go +++ b/internal/db/mocks.go @@ -1077,109 +1077,177 @@ 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 +// MockLoginSourcesStore is a mock implementation of the LoginSourcesStore +// interface (from the package gogs.io/gogs/internal/db) used for unit +// testing. +type MockLoginSourcesStore struct { + // CountFunc is an instance of a mock function object controlling the + // behavior of the method Count. + CountFunc *LoginSourcesStoreCountFunc + // CreateFunc is an instance of a mock function object controlling the + // behavior of the method Create. + CreateFunc *LoginSourcesStoreCreateFunc + // DeleteByIDFunc is an instance of a mock function object controlling + // the behavior of the method DeleteByID. + DeleteByIDFunc *LoginSourcesStoreDeleteByIDFunc + // GetByIDFunc is an instance of a mock function object controlling the + // behavior of the method GetByID. + GetByIDFunc *LoginSourcesStoreGetByIDFunc + // ListFunc is an instance of a mock function object controlling the + // behavior of the method List. + ListFunc *LoginSourcesStoreListFunc + // ResetNonDefaultFunc is an instance of a mock function object + // controlling the behavior of the method ResetNonDefault. + ResetNonDefaultFunc *LoginSourcesStoreResetNonDefaultFunc + // SaveFunc is an instance of a mock function object controlling the + // behavior of the method Save. + SaveFunc *LoginSourcesStoreSaveFunc } -// 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, AccessModeOptions) (r0 AccessMode) { +// NewMockLoginSourcesStore creates a new mock of the LoginSourcesStore +// interface. All methods return zero values for all results, unless +// overwritten. +func NewMockLoginSourcesStore() *MockLoginSourcesStore { + return &MockLoginSourcesStore{ + CountFunc: &LoginSourcesStoreCountFunc{ + defaultHook: func(context.Context) (r0 int64) { return }, }, - AuthorizeFunc: &PermsStoreAuthorizeFunc{ - defaultHook: func(context.Context, int64, int64, AccessMode, AccessModeOptions) (r0 bool) { + CreateFunc: &LoginSourcesStoreCreateFunc{ + defaultHook: func(context.Context, CreateLoginSourceOpts) (r0 *LoginSource, r1 error) { return }, }, - SetRepoPermsFunc: &PermsStoreSetRepoPermsFunc{ - defaultHook: func(context.Context, int64, map[int64]AccessMode) (r0 error) { + DeleteByIDFunc: &LoginSourcesStoreDeleteByIDFunc{ + defaultHook: func(context.Context, int64) (r0 error) { + return + }, + }, + GetByIDFunc: &LoginSourcesStoreGetByIDFunc{ + defaultHook: func(context.Context, int64) (r0 *LoginSource, r1 error) { + return + }, + }, + ListFunc: &LoginSourcesStoreListFunc{ + defaultHook: func(context.Context, ListLoginSourceOpts) (r0 []*LoginSource, r1 error) { + return + }, + }, + ResetNonDefaultFunc: &LoginSourcesStoreResetNonDefaultFunc{ + defaultHook: func(context.Context, *LoginSource) (r0 error) { + return + }, + }, + SaveFunc: &LoginSourcesStoreSaveFunc{ + defaultHook: func(context.Context, *LoginSource) (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, AccessModeOptions) AccessMode { - panic("unexpected invocation of MockPermsStore.AccessMode") +// NewStrictMockLoginSourcesStore creates a new mock of the +// LoginSourcesStore interface. All methods panic on invocation, unless +// overwritten. +func NewStrictMockLoginSourcesStore() *MockLoginSourcesStore { + return &MockLoginSourcesStore{ + CountFunc: &LoginSourcesStoreCountFunc{ + defaultHook: func(context.Context) int64 { + panic("unexpected invocation of MockLoginSourcesStore.Count") }, }, - AuthorizeFunc: &PermsStoreAuthorizeFunc{ - defaultHook: func(context.Context, int64, int64, AccessMode, AccessModeOptions) bool { - panic("unexpected invocation of MockPermsStore.Authorize") + CreateFunc: &LoginSourcesStoreCreateFunc{ + defaultHook: func(context.Context, CreateLoginSourceOpts) (*LoginSource, error) { + panic("unexpected invocation of MockLoginSourcesStore.Create") }, }, - SetRepoPermsFunc: &PermsStoreSetRepoPermsFunc{ - defaultHook: func(context.Context, int64, map[int64]AccessMode) error { - panic("unexpected invocation of MockPermsStore.SetRepoPerms") + DeleteByIDFunc: &LoginSourcesStoreDeleteByIDFunc{ + defaultHook: func(context.Context, int64) error { + panic("unexpected invocation of MockLoginSourcesStore.DeleteByID") + }, + }, + GetByIDFunc: &LoginSourcesStoreGetByIDFunc{ + defaultHook: func(context.Context, int64) (*LoginSource, error) { + panic("unexpected invocation of MockLoginSourcesStore.GetByID") + }, + }, + ListFunc: &LoginSourcesStoreListFunc{ + defaultHook: func(context.Context, ListLoginSourceOpts) ([]*LoginSource, error) { + panic("unexpected invocation of MockLoginSourcesStore.List") + }, + }, + ResetNonDefaultFunc: &LoginSourcesStoreResetNonDefaultFunc{ + defaultHook: func(context.Context, *LoginSource) error { + panic("unexpected invocation of MockLoginSourcesStore.ResetNonDefault") + }, + }, + SaveFunc: &LoginSourcesStoreSaveFunc{ + defaultHook: func(context.Context, *LoginSource) error { + panic("unexpected invocation of MockLoginSourcesStore.Save") }, }, } } -// NewMockPermsStoreFrom creates a new mock of the MockPermsStore interface. -// All methods delegate to the given implementation, unless overwritten. -func NewMockPermsStoreFrom(i PermsStore) *MockPermsStore { - return &MockPermsStore{ - AccessModeFunc: &PermsStoreAccessModeFunc{ - defaultHook: i.AccessMode, +// NewMockLoginSourcesStoreFrom creates a new mock of the +// MockLoginSourcesStore interface. All methods delegate to the given +// implementation, unless overwritten. +func NewMockLoginSourcesStoreFrom(i LoginSourcesStore) *MockLoginSourcesStore { + return &MockLoginSourcesStore{ + CountFunc: &LoginSourcesStoreCountFunc{ + defaultHook: i.Count, }, - AuthorizeFunc: &PermsStoreAuthorizeFunc{ - defaultHook: i.Authorize, + CreateFunc: &LoginSourcesStoreCreateFunc{ + defaultHook: i.Create, }, - SetRepoPermsFunc: &PermsStoreSetRepoPermsFunc{ - defaultHook: i.SetRepoPerms, + DeleteByIDFunc: &LoginSourcesStoreDeleteByIDFunc{ + defaultHook: i.DeleteByID, + }, + GetByIDFunc: &LoginSourcesStoreGetByIDFunc{ + defaultHook: i.GetByID, + }, + ListFunc: &LoginSourcesStoreListFunc{ + defaultHook: i.List, + }, + ResetNonDefaultFunc: &LoginSourcesStoreResetNonDefaultFunc{ + defaultHook: i.ResetNonDefault, + }, + SaveFunc: &LoginSourcesStoreSaveFunc{ + defaultHook: i.Save, }, } } -// PermsStoreAccessModeFunc describes the behavior when the AccessMode -// method of the parent MockPermsStore instance is invoked. -type PermsStoreAccessModeFunc struct { - defaultHook func(context.Context, int64, int64, AccessModeOptions) AccessMode - hooks []func(context.Context, int64, int64, AccessModeOptions) AccessMode - history []PermsStoreAccessModeFuncCall +// LoginSourcesStoreCountFunc describes the behavior when the Count method +// of the parent MockLoginSourcesStore instance is invoked. +type LoginSourcesStoreCountFunc struct { + defaultHook func(context.Context) int64 + hooks []func(context.Context) int64 + history []LoginSourcesStoreCountFuncCall 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 AccessModeOptions) AccessMode { - r0 := m.AccessModeFunc.nextHook()(v0, v1, v2, v3) - m.AccessModeFunc.appendCall(PermsStoreAccessModeFuncCall{v0, v1, v2, v3, r0}) +// Count delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockLoginSourcesStore) Count(v0 context.Context) int64 { + r0 := m.CountFunc.nextHook()(v0) + m.CountFunc.appendCall(LoginSourcesStoreCountFuncCall{v0, 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 +// SetDefaultHook sets function that is called when the Count method of the +// parent MockLoginSourcesStore instance is invoked and the hook queue is // empty. -func (f *PermsStoreAccessModeFunc) SetDefaultHook(hook func(context.Context, int64, int64, AccessModeOptions) AccessMode) { +func (f *LoginSourcesStoreCountFunc) SetDefaultHook(hook func(context.Context) int64) { 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, AccessModeOptions) AccessMode) { +// Count method of the parent MockLoginSourcesStore 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 *LoginSourcesStoreCountFunc) PushHook(hook func(context.Context) int64) { f.mutex.Lock() f.hooks = append(f.hooks, hook) f.mutex.Unlock() @@ -1187,20 +1255,20 @@ func (f *PermsStoreAccessModeFunc) PushHook(hook func(context.Context, int64, in // SetDefaultReturn calls SetDefaultHook with a function that returns the // given values. -func (f *PermsStoreAccessModeFunc) SetDefaultReturn(r0 AccessMode) { - f.SetDefaultHook(func(context.Context, int64, int64, AccessModeOptions) AccessMode { +func (f *LoginSourcesStoreCountFunc) SetDefaultReturn(r0 int64) { + f.SetDefaultHook(func(context.Context) int64 { return r0 }) } // PushReturn calls PushHook with a function that returns the given values. -func (f *PermsStoreAccessModeFunc) PushReturn(r0 AccessMode) { - f.PushHook(func(context.Context, int64, int64, AccessModeOptions) AccessMode { +func (f *LoginSourcesStoreCountFunc) PushReturn(r0 int64) { + f.PushHook(func(context.Context) int64 { return r0 }) } -func (f *PermsStoreAccessModeFunc) nextHook() func(context.Context, int64, int64, AccessModeOptions) AccessMode { +func (f *LoginSourcesStoreCountFunc) nextHook() func(context.Context) int64 { f.mutex.Lock() defer f.mutex.Unlock() @@ -1213,84 +1281,75 @@ func (f *PermsStoreAccessModeFunc) nextHook() func(context.Context, int64, int64 return hook } -func (f *PermsStoreAccessModeFunc) appendCall(r0 PermsStoreAccessModeFuncCall) { +func (f *LoginSourcesStoreCountFunc) appendCall(r0 LoginSourcesStoreCountFuncCall) { f.mutex.Lock() f.history = append(f.history, r0) f.mutex.Unlock() } -// History returns a sequence of PermsStoreAccessModeFuncCall objects +// History returns a sequence of LoginSourcesStoreCountFuncCall objects // describing the invocations of this function. -func (f *PermsStoreAccessModeFunc) History() []PermsStoreAccessModeFuncCall { +func (f *LoginSourcesStoreCountFunc) History() []LoginSourcesStoreCountFuncCall { f.mutex.Lock() - history := make([]PermsStoreAccessModeFuncCall, len(f.history)) + history := make([]LoginSourcesStoreCountFuncCall, 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 { +// LoginSourcesStoreCountFuncCall is an object that describes an invocation +// of method Count on an instance of MockLoginSourcesStore. +type LoginSourcesStoreCountFuncCall 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 AccessModeOptions // Result0 is the value of the 1st result returned from this method // invocation. - Result0 AccessMode + Result0 int64 } // 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} +func (c LoginSourcesStoreCountFuncCall) Args() []interface{} { + return []interface{}{c.Arg0} } // Results returns an interface slice containing the results of this // invocation. -func (c PermsStoreAccessModeFuncCall) Results() []interface{} { +func (c LoginSourcesStoreCountFuncCall) 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, AccessMode, AccessModeOptions) bool - hooks []func(context.Context, int64, int64, AccessMode, AccessModeOptions) bool - history []PermsStoreAuthorizeFuncCall +// LoginSourcesStoreCreateFunc describes the behavior when the Create method +// of the parent MockLoginSourcesStore instance is invoked. +type LoginSourcesStoreCreateFunc struct { + defaultHook func(context.Context, CreateLoginSourceOpts) (*LoginSource, error) + hooks []func(context.Context, CreateLoginSourceOpts) (*LoginSource, error) + history []LoginSourcesStoreCreateFuncCall mutex sync.Mutex } -// Authorize delegates to the next hook function in the queue and stores the +// Create 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 AccessMode, v4 AccessModeOptions) bool { - r0 := m.AuthorizeFunc.nextHook()(v0, v1, v2, v3, v4) - m.AuthorizeFunc.appendCall(PermsStoreAuthorizeFuncCall{v0, v1, v2, v3, v4, r0}) - return r0 +func (m *MockLoginSourcesStore) Create(v0 context.Context, v1 CreateLoginSourceOpts) (*LoginSource, error) { + r0, r1 := m.CreateFunc.nextHook()(v0, v1) + m.CreateFunc.appendCall(LoginSourcesStoreCreateFuncCall{v0, v1, r0, r1}) + return r0, r1 } -// SetDefaultHook sets function that is called when the Authorize method of -// the parent MockPermsStore instance is invoked and the hook queue is +// SetDefaultHook sets function that is called when the Create method of the +// parent MockLoginSourcesStore instance is invoked and the hook queue is // empty. -func (f *PermsStoreAuthorizeFunc) SetDefaultHook(hook func(context.Context, int64, int64, AccessMode, AccessModeOptions) bool) { +func (f *LoginSourcesStoreCreateFunc) SetDefaultHook(hook func(context.Context, CreateLoginSourceOpts) (*LoginSource, error)) { 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, AccessMode, AccessModeOptions) bool) { +// Create method of the parent MockLoginSourcesStore 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 *LoginSourcesStoreCreateFunc) PushHook(hook func(context.Context, CreateLoginSourceOpts) (*LoginSource, error)) { f.mutex.Lock() f.hooks = append(f.hooks, hook) f.mutex.Unlock() @@ -1298,20 +1357,20 @@ func (f *PermsStoreAuthorizeFunc) PushHook(hook func(context.Context, int64, int // SetDefaultReturn calls SetDefaultHook with a function that returns the // given values. -func (f *PermsStoreAuthorizeFunc) SetDefaultReturn(r0 bool) { - f.SetDefaultHook(func(context.Context, int64, int64, AccessMode, AccessModeOptions) bool { - return r0 +func (f *LoginSourcesStoreCreateFunc) SetDefaultReturn(r0 *LoginSource, r1 error) { + f.SetDefaultHook(func(context.Context, CreateLoginSourceOpts) (*LoginSource, error) { + return r0, r1 }) } // PushReturn calls PushHook with a function that returns the given values. -func (f *PermsStoreAuthorizeFunc) PushReturn(r0 bool) { - f.PushHook(func(context.Context, int64, int64, AccessMode, AccessModeOptions) bool { - return r0 +func (f *LoginSourcesStoreCreateFunc) PushReturn(r0 *LoginSource, r1 error) { + f.PushHook(func(context.Context, CreateLoginSourceOpts) (*LoginSource, error) { + return r0, r1 }) } -func (f *PermsStoreAuthorizeFunc) nextHook() func(context.Context, int64, int64, AccessMode, AccessModeOptions) bool { +func (f *LoginSourcesStoreCreateFunc) nextHook() func(context.Context, CreateLoginSourceOpts) (*LoginSource, error) { f.mutex.Lock() defer f.mutex.Unlock() @@ -1324,87 +1383,82 @@ func (f *PermsStoreAuthorizeFunc) nextHook() func(context.Context, int64, int64, return hook } -func (f *PermsStoreAuthorizeFunc) appendCall(r0 PermsStoreAuthorizeFuncCall) { +func (f *LoginSourcesStoreCreateFunc) appendCall(r0 LoginSourcesStoreCreateFuncCall) { f.mutex.Lock() f.history = append(f.history, r0) f.mutex.Unlock() } -// History returns a sequence of PermsStoreAuthorizeFuncCall objects +// History returns a sequence of LoginSourcesStoreCreateFuncCall objects // describing the invocations of this function. -func (f *PermsStoreAuthorizeFunc) History() []PermsStoreAuthorizeFuncCall { +func (f *LoginSourcesStoreCreateFunc) History() []LoginSourcesStoreCreateFuncCall { f.mutex.Lock() - history := make([]PermsStoreAuthorizeFuncCall, len(f.history)) + history := make([]LoginSourcesStoreCreateFuncCall, 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 { +// LoginSourcesStoreCreateFuncCall is an object that describes an invocation +// of method Create on an instance of MockLoginSourcesStore. +type LoginSourcesStoreCreateFuncCall 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 AccessMode - // Arg4 is the value of the 5th argument passed to this method - // invocation. - Arg4 AccessModeOptions + Arg1 CreateLoginSourceOpts // Result0 is the value of the 1st result returned from this method // invocation. - Result0 bool + Result0 *LoginSource + // 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 PermsStoreAuthorizeFuncCall) Args() []interface{} { - return []interface{}{c.Arg0, c.Arg1, c.Arg2, c.Arg3, c.Arg4} +func (c LoginSourcesStoreCreateFuncCall) Args() []interface{} { + return []interface{}{c.Arg0, c.Arg1} } // Results returns an interface slice containing the results of this // invocation. -func (c PermsStoreAuthorizeFuncCall) Results() []interface{} { - return []interface{}{c.Result0} +func (c LoginSourcesStoreCreateFuncCall) Results() []interface{} { + return []interface{}{c.Result0, c.Result1} } -// 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]AccessMode) error - hooks []func(context.Context, int64, map[int64]AccessMode) error - history []PermsStoreSetRepoPermsFuncCall +// LoginSourcesStoreDeleteByIDFunc describes the behavior when the +// DeleteByID method of the parent MockLoginSourcesStore instance is +// invoked. +type LoginSourcesStoreDeleteByIDFunc struct { + defaultHook func(context.Context, int64) error + hooks []func(context.Context, int64) error + history []LoginSourcesStoreDeleteByIDFuncCall mutex sync.Mutex } -// SetRepoPerms delegates to the next hook function in the queue and stores +// DeleteByID 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]AccessMode) error { - r0 := m.SetRepoPermsFunc.nextHook()(v0, v1, v2) - m.SetRepoPermsFunc.appendCall(PermsStoreSetRepoPermsFuncCall{v0, v1, v2, r0}) +func (m *MockLoginSourcesStore) DeleteByID(v0 context.Context, v1 int64) error { + r0 := m.DeleteByIDFunc.nextHook()(v0, v1) + m.DeleteByIDFunc.appendCall(LoginSourcesStoreDeleteByIDFuncCall{v0, v1, 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]AccessMode) error) { +// SetDefaultHook sets function that is called when the DeleteByID method of +// the parent MockLoginSourcesStore instance is invoked and the hook queue +// is empty. +func (f *LoginSourcesStoreDeleteByIDFunc) SetDefaultHook(hook func(context.Context, int64) 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]AccessMode) error) { +// DeleteByID method of the parent MockLoginSourcesStore 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 *LoginSourcesStoreDeleteByIDFunc) PushHook(hook func(context.Context, int64) error) { f.mutex.Lock() f.hooks = append(f.hooks, hook) f.mutex.Unlock() @@ -1412,20 +1466,20 @@ func (f *PermsStoreSetRepoPermsFunc) PushHook(hook func(context.Context, int64, // 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]AccessMode) error { +func (f *LoginSourcesStoreDeleteByIDFunc) 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 *PermsStoreSetRepoPermsFunc) PushReturn(r0 error) { - f.PushHook(func(context.Context, int64, map[int64]AccessMode) error { +func (f *LoginSourcesStoreDeleteByIDFunc) PushReturn(r0 error) { + f.PushHook(func(context.Context, int64) error { return r0 }) } -func (f *PermsStoreSetRepoPermsFunc) nextHook() func(context.Context, int64, map[int64]AccessMode) error { +func (f *LoginSourcesStoreDeleteByIDFunc) nextHook() func(context.Context, int64) error { f.mutex.Lock() defer f.mutex.Unlock() @@ -1438,35 +1492,32 @@ func (f *PermsStoreSetRepoPermsFunc) nextHook() func(context.Context, int64, map return hook } -func (f *PermsStoreSetRepoPermsFunc) appendCall(r0 PermsStoreSetRepoPermsFuncCall) { +func (f *LoginSourcesStoreDeleteByIDFunc) appendCall(r0 LoginSourcesStoreDeleteByIDFuncCall) { f.mutex.Lock() f.history = append(f.history, r0) f.mutex.Unlock() } -// History returns a sequence of PermsStoreSetRepoPermsFuncCall objects +// History returns a sequence of LoginSourcesStoreDeleteByIDFuncCall objects // describing the invocations of this function. -func (f *PermsStoreSetRepoPermsFunc) History() []PermsStoreSetRepoPermsFuncCall { +func (f *LoginSourcesStoreDeleteByIDFunc) History() []LoginSourcesStoreDeleteByIDFuncCall { f.mutex.Lock() - history := make([]PermsStoreSetRepoPermsFuncCall, len(f.history)) + history := make([]LoginSourcesStoreDeleteByIDFuncCall, 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 { +// LoginSourcesStoreDeleteByIDFuncCall is an object that describes an +// invocation of method DeleteByID on an instance of MockLoginSourcesStore. +type LoginSourcesStoreDeleteByIDFuncCall 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]AccessMode // Result0 is the value of the 1st result returned from this method // invocation. Result0 error @@ -1474,12 +1525,1751 @@ type PermsStoreSetRepoPermsFuncCall struct { // Args returns an interface slice containing the arguments of this // invocation. -func (c PermsStoreSetRepoPermsFuncCall) Args() []interface{} { - return []interface{}{c.Arg0, c.Arg1, c.Arg2} +func (c LoginSourcesStoreDeleteByIDFuncCall) Args() []interface{} { + return []interface{}{c.Arg0, c.Arg1} } // Results returns an interface slice containing the results of this // invocation. -func (c PermsStoreSetRepoPermsFuncCall) Results() []interface{} { +func (c LoginSourcesStoreDeleteByIDFuncCall) Results() []interface{} { return []interface{}{c.Result0} } + +// LoginSourcesStoreGetByIDFunc describes the behavior when the GetByID +// method of the parent MockLoginSourcesStore instance is invoked. +type LoginSourcesStoreGetByIDFunc struct { + defaultHook func(context.Context, int64) (*LoginSource, error) + hooks []func(context.Context, int64) (*LoginSource, error) + history []LoginSourcesStoreGetByIDFuncCall + 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 *MockLoginSourcesStore) GetByID(v0 context.Context, v1 int64) (*LoginSource, error) { + r0, r1 := m.GetByIDFunc.nextHook()(v0, v1) + m.GetByIDFunc.appendCall(LoginSourcesStoreGetByIDFuncCall{v0, v1, r0, r1}) + return r0, r1 +} + +// SetDefaultHook sets function that is called when the GetByID method of +// the parent MockLoginSourcesStore instance is invoked and the hook queue +// is empty. +func (f *LoginSourcesStoreGetByIDFunc) SetDefaultHook(hook func(context.Context, int64) (*LoginSource, error)) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// GetByID method of the parent MockLoginSourcesStore 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 *LoginSourcesStoreGetByIDFunc) PushHook(hook func(context.Context, int64) (*LoginSource, 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 *LoginSourcesStoreGetByIDFunc) SetDefaultReturn(r0 *LoginSource, r1 error) { + f.SetDefaultHook(func(context.Context, int64) (*LoginSource, error) { + return r0, r1 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *LoginSourcesStoreGetByIDFunc) PushReturn(r0 *LoginSource, r1 error) { + f.PushHook(func(context.Context, int64) (*LoginSource, error) { + return r0, r1 + }) +} + +func (f *LoginSourcesStoreGetByIDFunc) nextHook() func(context.Context, int64) (*LoginSource, 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 *LoginSourcesStoreGetByIDFunc) appendCall(r0 LoginSourcesStoreGetByIDFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of LoginSourcesStoreGetByIDFuncCall objects +// describing the invocations of this function. +func (f *LoginSourcesStoreGetByIDFunc) History() []LoginSourcesStoreGetByIDFuncCall { + f.mutex.Lock() + history := make([]LoginSourcesStoreGetByIDFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// LoginSourcesStoreGetByIDFuncCall is an object that describes an +// invocation of method GetByID on an instance of MockLoginSourcesStore. +type LoginSourcesStoreGetByIDFuncCall 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 *LoginSource + // 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 LoginSourcesStoreGetByIDFuncCall) Args() []interface{} { + return []interface{}{c.Arg0, c.Arg1} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c LoginSourcesStoreGetByIDFuncCall) Results() []interface{} { + return []interface{}{c.Result0, c.Result1} +} + +// LoginSourcesStoreListFunc describes the behavior when the List method of +// the parent MockLoginSourcesStore instance is invoked. +type LoginSourcesStoreListFunc struct { + defaultHook func(context.Context, ListLoginSourceOpts) ([]*LoginSource, error) + hooks []func(context.Context, ListLoginSourceOpts) ([]*LoginSource, error) + history []LoginSourcesStoreListFuncCall + 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 *MockLoginSourcesStore) List(v0 context.Context, v1 ListLoginSourceOpts) ([]*LoginSource, error) { + r0, r1 := m.ListFunc.nextHook()(v0, v1) + m.ListFunc.appendCall(LoginSourcesStoreListFuncCall{v0, v1, r0, r1}) + return r0, r1 +} + +// SetDefaultHook sets function that is called when the List method of the +// parent MockLoginSourcesStore instance is invoked and the hook queue is +// empty. +func (f *LoginSourcesStoreListFunc) SetDefaultHook(hook func(context.Context, ListLoginSourceOpts) ([]*LoginSource, error)) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// List method of the parent MockLoginSourcesStore 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 *LoginSourcesStoreListFunc) PushHook(hook func(context.Context, ListLoginSourceOpts) ([]*LoginSource, 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 *LoginSourcesStoreListFunc) SetDefaultReturn(r0 []*LoginSource, r1 error) { + f.SetDefaultHook(func(context.Context, ListLoginSourceOpts) ([]*LoginSource, error) { + return r0, r1 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *LoginSourcesStoreListFunc) PushReturn(r0 []*LoginSource, r1 error) { + f.PushHook(func(context.Context, ListLoginSourceOpts) ([]*LoginSource, error) { + return r0, r1 + }) +} + +func (f *LoginSourcesStoreListFunc) nextHook() func(context.Context, ListLoginSourceOpts) ([]*LoginSource, 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 *LoginSourcesStoreListFunc) appendCall(r0 LoginSourcesStoreListFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of LoginSourcesStoreListFuncCall objects +// describing the invocations of this function. +func (f *LoginSourcesStoreListFunc) History() []LoginSourcesStoreListFuncCall { + f.mutex.Lock() + history := make([]LoginSourcesStoreListFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// LoginSourcesStoreListFuncCall is an object that describes an invocation +// of method List on an instance of MockLoginSourcesStore. +type LoginSourcesStoreListFuncCall 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 ListLoginSourceOpts + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 []*LoginSource + // 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 LoginSourcesStoreListFuncCall) Args() []interface{} { + return []interface{}{c.Arg0, c.Arg1} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c LoginSourcesStoreListFuncCall) Results() []interface{} { + return []interface{}{c.Result0, c.Result1} +} + +// LoginSourcesStoreResetNonDefaultFunc describes the behavior when the +// ResetNonDefault method of the parent MockLoginSourcesStore instance is +// invoked. +type LoginSourcesStoreResetNonDefaultFunc struct { + defaultHook func(context.Context, *LoginSource) error + hooks []func(context.Context, *LoginSource) error + history []LoginSourcesStoreResetNonDefaultFuncCall + mutex sync.Mutex +} + +// ResetNonDefault delegates to the next hook function in the queue and +// stores the parameter and result values of this invocation. +func (m *MockLoginSourcesStore) ResetNonDefault(v0 context.Context, v1 *LoginSource) error { + r0 := m.ResetNonDefaultFunc.nextHook()(v0, v1) + m.ResetNonDefaultFunc.appendCall(LoginSourcesStoreResetNonDefaultFuncCall{v0, v1, r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the ResetNonDefault +// method of the parent MockLoginSourcesStore instance is invoked and the +// hook queue is empty. +func (f *LoginSourcesStoreResetNonDefaultFunc) SetDefaultHook(hook func(context.Context, *LoginSource) error) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// ResetNonDefault method of the parent MockLoginSourcesStore 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 *LoginSourcesStoreResetNonDefaultFunc) PushHook(hook func(context.Context, *LoginSource) 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 *LoginSourcesStoreResetNonDefaultFunc) SetDefaultReturn(r0 error) { + f.SetDefaultHook(func(context.Context, *LoginSource) error { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *LoginSourcesStoreResetNonDefaultFunc) PushReturn(r0 error) { + f.PushHook(func(context.Context, *LoginSource) error { + return r0 + }) +} + +func (f *LoginSourcesStoreResetNonDefaultFunc) nextHook() func(context.Context, *LoginSource) 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 *LoginSourcesStoreResetNonDefaultFunc) appendCall(r0 LoginSourcesStoreResetNonDefaultFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of LoginSourcesStoreResetNonDefaultFuncCall +// objects describing the invocations of this function. +func (f *LoginSourcesStoreResetNonDefaultFunc) History() []LoginSourcesStoreResetNonDefaultFuncCall { + f.mutex.Lock() + history := make([]LoginSourcesStoreResetNonDefaultFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// LoginSourcesStoreResetNonDefaultFuncCall is an object that describes an +// invocation of method ResetNonDefault on an instance of +// MockLoginSourcesStore. +type LoginSourcesStoreResetNonDefaultFuncCall 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 *LoginSource + // 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 LoginSourcesStoreResetNonDefaultFuncCall) Args() []interface{} { + return []interface{}{c.Arg0, c.Arg1} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c LoginSourcesStoreResetNonDefaultFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// LoginSourcesStoreSaveFunc describes the behavior when the Save method of +// the parent MockLoginSourcesStore instance is invoked. +type LoginSourcesStoreSaveFunc struct { + defaultHook func(context.Context, *LoginSource) error + hooks []func(context.Context, *LoginSource) error + history []LoginSourcesStoreSaveFuncCall + mutex sync.Mutex +} + +// Save delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockLoginSourcesStore) Save(v0 context.Context, v1 *LoginSource) error { + r0 := m.SaveFunc.nextHook()(v0, v1) + m.SaveFunc.appendCall(LoginSourcesStoreSaveFuncCall{v0, v1, r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the Save method of the +// parent MockLoginSourcesStore instance is invoked and the hook queue is +// empty. +func (f *LoginSourcesStoreSaveFunc) SetDefaultHook(hook func(context.Context, *LoginSource) error) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// Save method of the parent MockLoginSourcesStore 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 *LoginSourcesStoreSaveFunc) PushHook(hook func(context.Context, *LoginSource) 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 *LoginSourcesStoreSaveFunc) SetDefaultReturn(r0 error) { + f.SetDefaultHook(func(context.Context, *LoginSource) error { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *LoginSourcesStoreSaveFunc) PushReturn(r0 error) { + f.PushHook(func(context.Context, *LoginSource) error { + return r0 + }) +} + +func (f *LoginSourcesStoreSaveFunc) nextHook() func(context.Context, *LoginSource) 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 *LoginSourcesStoreSaveFunc) appendCall(r0 LoginSourcesStoreSaveFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of LoginSourcesStoreSaveFuncCall objects +// describing the invocations of this function. +func (f *LoginSourcesStoreSaveFunc) History() []LoginSourcesStoreSaveFuncCall { + f.mutex.Lock() + history := make([]LoginSourcesStoreSaveFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// LoginSourcesStoreSaveFuncCall is an object that describes an invocation +// of method Save on an instance of MockLoginSourcesStore. +type LoginSourcesStoreSaveFuncCall 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 *LoginSource + // 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 LoginSourcesStoreSaveFuncCall) Args() []interface{} { + return []interface{}{c.Arg0, c.Arg1} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c LoginSourcesStoreSaveFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// 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, AccessModeOptions) (r0 AccessMode) { + return + }, + }, + AuthorizeFunc: &PermsStoreAuthorizeFunc{ + defaultHook: func(context.Context, int64, int64, AccessMode, AccessModeOptions) (r0 bool) { + return + }, + }, + SetRepoPermsFunc: &PermsStoreSetRepoPermsFunc{ + defaultHook: func(context.Context, int64, map[int64]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, AccessModeOptions) AccessMode { + panic("unexpected invocation of MockPermsStore.AccessMode") + }, + }, + AuthorizeFunc: &PermsStoreAuthorizeFunc{ + defaultHook: func(context.Context, int64, int64, AccessMode, AccessModeOptions) bool { + panic("unexpected invocation of MockPermsStore.Authorize") + }, + }, + SetRepoPermsFunc: &PermsStoreSetRepoPermsFunc{ + defaultHook: func(context.Context, int64, map[int64]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 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, AccessModeOptions) AccessMode + hooks []func(context.Context, int64, int64, AccessModeOptions) 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 AccessModeOptions) 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, AccessModeOptions) 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, AccessModeOptions) 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 AccessMode) { + f.SetDefaultHook(func(context.Context, int64, int64, AccessModeOptions) AccessMode { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *PermsStoreAccessModeFunc) PushReturn(r0 AccessMode) { + f.PushHook(func(context.Context, int64, int64, AccessModeOptions) AccessMode { + return r0 + }) +} + +func (f *PermsStoreAccessModeFunc) nextHook() func(context.Context, int64, int64, AccessModeOptions) 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 AccessModeOptions + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 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, AccessMode, AccessModeOptions) bool + hooks []func(context.Context, int64, int64, AccessMode, 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 AccessMode, v4 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, AccessMode, 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, AccessMode, 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, AccessMode, 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, AccessMode, AccessModeOptions) bool { + return r0 + }) +} + +func (f *PermsStoreAuthorizeFunc) nextHook() func(context.Context, int64, int64, AccessMode, 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 AccessMode + // Arg4 is the value of the 5th argument passed to this method + // invocation. + Arg4 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]AccessMode) error + hooks []func(context.Context, int64, map[int64]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]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]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]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]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]AccessMode) error { + return r0 + }) +} + +func (f *PermsStoreSetRepoPermsFunc) nextHook() func(context.Context, int64, map[int64]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]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} +} + +// MockLoginSourceFileStore is a mock implementation of the +// loginSourceFileStore interface (from the package +// gogs.io/gogs/internal/db) used for unit testing. +type MockLoginSourceFileStore struct { + // SaveFunc is an instance of a mock function object controlling the + // behavior of the method Save. + SaveFunc *LoginSourceFileStoreSaveFunc + // SetConfigFunc is an instance of a mock function object controlling + // the behavior of the method SetConfig. + SetConfigFunc *LoginSourceFileStoreSetConfigFunc + // SetGeneralFunc is an instance of a mock function object controlling + // the behavior of the method SetGeneral. + SetGeneralFunc *LoginSourceFileStoreSetGeneralFunc +} + +// NewMockLoginSourceFileStore creates a new mock of the +// loginSourceFileStore interface. All methods return zero values for all +// results, unless overwritten. +func NewMockLoginSourceFileStore() *MockLoginSourceFileStore { + return &MockLoginSourceFileStore{ + SaveFunc: &LoginSourceFileStoreSaveFunc{ + defaultHook: func() (r0 error) { + return + }, + }, + SetConfigFunc: &LoginSourceFileStoreSetConfigFunc{ + defaultHook: func(interface{}) (r0 error) { + return + }, + }, + SetGeneralFunc: &LoginSourceFileStoreSetGeneralFunc{ + defaultHook: func(string, string) { + return + }, + }, + } +} + +// NewStrictMockLoginSourceFileStore creates a new mock of the +// loginSourceFileStore interface. All methods panic on invocation, unless +// overwritten. +func NewStrictMockLoginSourceFileStore() *MockLoginSourceFileStore { + return &MockLoginSourceFileStore{ + SaveFunc: &LoginSourceFileStoreSaveFunc{ + defaultHook: func() error { + panic("unexpected invocation of MockLoginSourceFileStore.Save") + }, + }, + SetConfigFunc: &LoginSourceFileStoreSetConfigFunc{ + defaultHook: func(interface{}) error { + panic("unexpected invocation of MockLoginSourceFileStore.SetConfig") + }, + }, + SetGeneralFunc: &LoginSourceFileStoreSetGeneralFunc{ + defaultHook: func(string, string) { + panic("unexpected invocation of MockLoginSourceFileStore.SetGeneral") + }, + }, + } +} + +// surrogateMockLoginSourceFileStore is a copy of the loginSourceFileStore +// interface (from the package gogs.io/gogs/internal/db). It is redefined +// here as it is unexported in the source package. +type surrogateMockLoginSourceFileStore interface { + Save() error + SetConfig(interface{}) error + SetGeneral(string, string) +} + +// NewMockLoginSourceFileStoreFrom creates a new mock of the +// MockLoginSourceFileStore interface. All methods delegate to the given +// implementation, unless overwritten. +func NewMockLoginSourceFileStoreFrom(i surrogateMockLoginSourceFileStore) *MockLoginSourceFileStore { + return &MockLoginSourceFileStore{ + SaveFunc: &LoginSourceFileStoreSaveFunc{ + defaultHook: i.Save, + }, + SetConfigFunc: &LoginSourceFileStoreSetConfigFunc{ + defaultHook: i.SetConfig, + }, + SetGeneralFunc: &LoginSourceFileStoreSetGeneralFunc{ + defaultHook: i.SetGeneral, + }, + } +} + +// LoginSourceFileStoreSaveFunc describes the behavior when the Save method +// of the parent MockLoginSourceFileStore instance is invoked. +type LoginSourceFileStoreSaveFunc struct { + defaultHook func() error + hooks []func() error + history []LoginSourceFileStoreSaveFuncCall + mutex sync.Mutex +} + +// Save delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockLoginSourceFileStore) Save() error { + r0 := m.SaveFunc.nextHook()() + m.SaveFunc.appendCall(LoginSourceFileStoreSaveFuncCall{r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the Save method of the +// parent MockLoginSourceFileStore instance is invoked and the hook queue is +// empty. +func (f *LoginSourceFileStoreSaveFunc) SetDefaultHook(hook func() error) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// Save method of the parent MockLoginSourceFileStore 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 *LoginSourceFileStoreSaveFunc) PushHook(hook func() 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 *LoginSourceFileStoreSaveFunc) SetDefaultReturn(r0 error) { + f.SetDefaultHook(func() error { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *LoginSourceFileStoreSaveFunc) PushReturn(r0 error) { + f.PushHook(func() error { + return r0 + }) +} + +func (f *LoginSourceFileStoreSaveFunc) nextHook() func() 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 *LoginSourceFileStoreSaveFunc) appendCall(r0 LoginSourceFileStoreSaveFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of LoginSourceFileStoreSaveFuncCall objects +// describing the invocations of this function. +func (f *LoginSourceFileStoreSaveFunc) History() []LoginSourceFileStoreSaveFuncCall { + f.mutex.Lock() + history := make([]LoginSourceFileStoreSaveFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// LoginSourceFileStoreSaveFuncCall is an object that describes an +// invocation of method Save on an instance of MockLoginSourceFileStore. +type LoginSourceFileStoreSaveFuncCall struct { + // 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 LoginSourceFileStoreSaveFuncCall) Args() []interface{} { + return []interface{}{} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c LoginSourceFileStoreSaveFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// LoginSourceFileStoreSetConfigFunc describes the behavior when the +// SetConfig method of the parent MockLoginSourceFileStore instance is +// invoked. +type LoginSourceFileStoreSetConfigFunc struct { + defaultHook func(interface{}) error + hooks []func(interface{}) error + history []LoginSourceFileStoreSetConfigFuncCall + mutex sync.Mutex +} + +// SetConfig delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockLoginSourceFileStore) SetConfig(v0 interface{}) error { + r0 := m.SetConfigFunc.nextHook()(v0) + m.SetConfigFunc.appendCall(LoginSourceFileStoreSetConfigFuncCall{v0, r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the SetConfig method of +// the parent MockLoginSourceFileStore instance is invoked and the hook +// queue is empty. +func (f *LoginSourceFileStoreSetConfigFunc) SetDefaultHook(hook func(interface{}) error) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// SetConfig method of the parent MockLoginSourceFileStore 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 *LoginSourceFileStoreSetConfigFunc) PushHook(hook func(interface{}) 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 *LoginSourceFileStoreSetConfigFunc) SetDefaultReturn(r0 error) { + f.SetDefaultHook(func(interface{}) error { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *LoginSourceFileStoreSetConfigFunc) PushReturn(r0 error) { + f.PushHook(func(interface{}) error { + return r0 + }) +} + +func (f *LoginSourceFileStoreSetConfigFunc) nextHook() func(interface{}) 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 *LoginSourceFileStoreSetConfigFunc) appendCall(r0 LoginSourceFileStoreSetConfigFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of LoginSourceFileStoreSetConfigFuncCall +// objects describing the invocations of this function. +func (f *LoginSourceFileStoreSetConfigFunc) History() []LoginSourceFileStoreSetConfigFuncCall { + f.mutex.Lock() + history := make([]LoginSourceFileStoreSetConfigFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// LoginSourceFileStoreSetConfigFuncCall is an object that describes an +// invocation of method SetConfig on an instance of +// MockLoginSourceFileStore. +type LoginSourceFileStoreSetConfigFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 interface{} + // 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 LoginSourceFileStoreSetConfigFuncCall) Args() []interface{} { + return []interface{}{c.Arg0} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c LoginSourceFileStoreSetConfigFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// LoginSourceFileStoreSetGeneralFunc describes the behavior when the +// SetGeneral method of the parent MockLoginSourceFileStore instance is +// invoked. +type LoginSourceFileStoreSetGeneralFunc struct { + defaultHook func(string, string) + hooks []func(string, string) + history []LoginSourceFileStoreSetGeneralFuncCall + mutex sync.Mutex +} + +// SetGeneral delegates to the next hook function in the queue and stores +// the parameter and result values of this invocation. +func (m *MockLoginSourceFileStore) SetGeneral(v0 string, v1 string) { + m.SetGeneralFunc.nextHook()(v0, v1) + m.SetGeneralFunc.appendCall(LoginSourceFileStoreSetGeneralFuncCall{v0, v1}) + return +} + +// SetDefaultHook sets function that is called when the SetGeneral method of +// the parent MockLoginSourceFileStore instance is invoked and the hook +// queue is empty. +func (f *LoginSourceFileStoreSetGeneralFunc) SetDefaultHook(hook func(string, string)) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// SetGeneral method of the parent MockLoginSourceFileStore 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 *LoginSourceFileStoreSetGeneralFunc) PushHook(hook func(string, string)) { + 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 *LoginSourceFileStoreSetGeneralFunc) SetDefaultReturn() { + f.SetDefaultHook(func(string, string) { + return + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *LoginSourceFileStoreSetGeneralFunc) PushReturn() { + f.PushHook(func(string, string) { + return + }) +} + +func (f *LoginSourceFileStoreSetGeneralFunc) nextHook() func(string, string) { + 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 *LoginSourceFileStoreSetGeneralFunc) appendCall(r0 LoginSourceFileStoreSetGeneralFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of LoginSourceFileStoreSetGeneralFuncCall +// objects describing the invocations of this function. +func (f *LoginSourceFileStoreSetGeneralFunc) History() []LoginSourceFileStoreSetGeneralFuncCall { + f.mutex.Lock() + history := make([]LoginSourceFileStoreSetGeneralFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// LoginSourceFileStoreSetGeneralFuncCall is an object that describes an +// invocation of method SetGeneral on an instance of +// MockLoginSourceFileStore. +type LoginSourceFileStoreSetGeneralFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 string + // Arg1 is the value of the 2nd argument passed to this method + // invocation. + Arg1 string +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c LoginSourceFileStoreSetGeneralFuncCall) Args() []interface{} { + return []interface{}{c.Arg0, c.Arg1} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c LoginSourceFileStoreSetGeneralFuncCall) Results() []interface{} { + return []interface{}{} +} + +// MockLoginSourceFilesStore is a mock implementation of the +// loginSourceFilesStore interface (from the package +// gogs.io/gogs/internal/db) used for unit testing. +type MockLoginSourceFilesStore struct { + // GetByIDFunc is an instance of a mock function object controlling the + // behavior of the method GetByID. + GetByIDFunc *LoginSourceFilesStoreGetByIDFunc + // LenFunc is an instance of a mock function object controlling the + // behavior of the method Len. + LenFunc *LoginSourceFilesStoreLenFunc + // ListFunc is an instance of a mock function object controlling the + // behavior of the method List. + ListFunc *LoginSourceFilesStoreListFunc + // UpdateFunc is an instance of a mock function object controlling the + // behavior of the method Update. + UpdateFunc *LoginSourceFilesStoreUpdateFunc +} + +// NewMockLoginSourceFilesStore creates a new mock of the +// loginSourceFilesStore interface. All methods return zero values for all +// results, unless overwritten. +func NewMockLoginSourceFilesStore() *MockLoginSourceFilesStore { + return &MockLoginSourceFilesStore{ + GetByIDFunc: &LoginSourceFilesStoreGetByIDFunc{ + defaultHook: func(int64) (r0 *LoginSource, r1 error) { + return + }, + }, + LenFunc: &LoginSourceFilesStoreLenFunc{ + defaultHook: func() (r0 int) { + return + }, + }, + ListFunc: &LoginSourceFilesStoreListFunc{ + defaultHook: func(ListLoginSourceOpts) (r0 []*LoginSource) { + return + }, + }, + UpdateFunc: &LoginSourceFilesStoreUpdateFunc{ + defaultHook: func(*LoginSource) { + return + }, + }, + } +} + +// NewStrictMockLoginSourceFilesStore creates a new mock of the +// loginSourceFilesStore interface. All methods panic on invocation, unless +// overwritten. +func NewStrictMockLoginSourceFilesStore() *MockLoginSourceFilesStore { + return &MockLoginSourceFilesStore{ + GetByIDFunc: &LoginSourceFilesStoreGetByIDFunc{ + defaultHook: func(int64) (*LoginSource, error) { + panic("unexpected invocation of MockLoginSourceFilesStore.GetByID") + }, + }, + LenFunc: &LoginSourceFilesStoreLenFunc{ + defaultHook: func() int { + panic("unexpected invocation of MockLoginSourceFilesStore.Len") + }, + }, + ListFunc: &LoginSourceFilesStoreListFunc{ + defaultHook: func(ListLoginSourceOpts) []*LoginSource { + panic("unexpected invocation of MockLoginSourceFilesStore.List") + }, + }, + UpdateFunc: &LoginSourceFilesStoreUpdateFunc{ + defaultHook: func(*LoginSource) { + panic("unexpected invocation of MockLoginSourceFilesStore.Update") + }, + }, + } +} + +// surrogateMockLoginSourceFilesStore is a copy of the loginSourceFilesStore +// interface (from the package gogs.io/gogs/internal/db). It is redefined +// here as it is unexported in the source package. +type surrogateMockLoginSourceFilesStore interface { + GetByID(int64) (*LoginSource, error) + Len() int + List(ListLoginSourceOpts) []*LoginSource + Update(*LoginSource) +} + +// NewMockLoginSourceFilesStoreFrom creates a new mock of the +// MockLoginSourceFilesStore interface. All methods delegate to the given +// implementation, unless overwritten. +func NewMockLoginSourceFilesStoreFrom(i surrogateMockLoginSourceFilesStore) *MockLoginSourceFilesStore { + return &MockLoginSourceFilesStore{ + GetByIDFunc: &LoginSourceFilesStoreGetByIDFunc{ + defaultHook: i.GetByID, + }, + LenFunc: &LoginSourceFilesStoreLenFunc{ + defaultHook: i.Len, + }, + ListFunc: &LoginSourceFilesStoreListFunc{ + defaultHook: i.List, + }, + UpdateFunc: &LoginSourceFilesStoreUpdateFunc{ + defaultHook: i.Update, + }, + } +} + +// LoginSourceFilesStoreGetByIDFunc describes the behavior when the GetByID +// method of the parent MockLoginSourceFilesStore instance is invoked. +type LoginSourceFilesStoreGetByIDFunc struct { + defaultHook func(int64) (*LoginSource, error) + hooks []func(int64) (*LoginSource, error) + history []LoginSourceFilesStoreGetByIDFuncCall + 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 *MockLoginSourceFilesStore) GetByID(v0 int64) (*LoginSource, error) { + r0, r1 := m.GetByIDFunc.nextHook()(v0) + m.GetByIDFunc.appendCall(LoginSourceFilesStoreGetByIDFuncCall{v0, r0, r1}) + return r0, r1 +} + +// SetDefaultHook sets function that is called when the GetByID method of +// the parent MockLoginSourceFilesStore instance is invoked and the hook +// queue is empty. +func (f *LoginSourceFilesStoreGetByIDFunc) SetDefaultHook(hook func(int64) (*LoginSource, error)) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// GetByID method of the parent MockLoginSourceFilesStore 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 *LoginSourceFilesStoreGetByIDFunc) PushHook(hook func(int64) (*LoginSource, 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 *LoginSourceFilesStoreGetByIDFunc) SetDefaultReturn(r0 *LoginSource, r1 error) { + f.SetDefaultHook(func(int64) (*LoginSource, error) { + return r0, r1 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *LoginSourceFilesStoreGetByIDFunc) PushReturn(r0 *LoginSource, r1 error) { + f.PushHook(func(int64) (*LoginSource, error) { + return r0, r1 + }) +} + +func (f *LoginSourceFilesStoreGetByIDFunc) nextHook() func(int64) (*LoginSource, 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 *LoginSourceFilesStoreGetByIDFunc) appendCall(r0 LoginSourceFilesStoreGetByIDFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of LoginSourceFilesStoreGetByIDFuncCall +// objects describing the invocations of this function. +func (f *LoginSourceFilesStoreGetByIDFunc) History() []LoginSourceFilesStoreGetByIDFuncCall { + f.mutex.Lock() + history := make([]LoginSourceFilesStoreGetByIDFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// LoginSourceFilesStoreGetByIDFuncCall is an object that describes an +// invocation of method GetByID on an instance of MockLoginSourceFilesStore. +type LoginSourceFilesStoreGetByIDFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 int64 + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 *LoginSource + // 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 LoginSourceFilesStoreGetByIDFuncCall) Args() []interface{} { + return []interface{}{c.Arg0} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c LoginSourceFilesStoreGetByIDFuncCall) Results() []interface{} { + return []interface{}{c.Result0, c.Result1} +} + +// LoginSourceFilesStoreLenFunc describes the behavior when the Len method +// of the parent MockLoginSourceFilesStore instance is invoked. +type LoginSourceFilesStoreLenFunc struct { + defaultHook func() int + hooks []func() int + history []LoginSourceFilesStoreLenFuncCall + mutex sync.Mutex +} + +// Len delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockLoginSourceFilesStore) Len() int { + r0 := m.LenFunc.nextHook()() + m.LenFunc.appendCall(LoginSourceFilesStoreLenFuncCall{r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the Len method of the +// parent MockLoginSourceFilesStore instance is invoked and the hook queue +// is empty. +func (f *LoginSourceFilesStoreLenFunc) SetDefaultHook(hook func() int) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// Len method of the parent MockLoginSourceFilesStore 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 *LoginSourceFilesStoreLenFunc) PushHook(hook func() int) { + 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 *LoginSourceFilesStoreLenFunc) SetDefaultReturn(r0 int) { + f.SetDefaultHook(func() int { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *LoginSourceFilesStoreLenFunc) PushReturn(r0 int) { + f.PushHook(func() int { + return r0 + }) +} + +func (f *LoginSourceFilesStoreLenFunc) nextHook() func() int { + 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 *LoginSourceFilesStoreLenFunc) appendCall(r0 LoginSourceFilesStoreLenFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of LoginSourceFilesStoreLenFuncCall objects +// describing the invocations of this function. +func (f *LoginSourceFilesStoreLenFunc) History() []LoginSourceFilesStoreLenFuncCall { + f.mutex.Lock() + history := make([]LoginSourceFilesStoreLenFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// LoginSourceFilesStoreLenFuncCall is an object that describes an +// invocation of method Len on an instance of MockLoginSourceFilesStore. +type LoginSourceFilesStoreLenFuncCall struct { + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 int +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c LoginSourceFilesStoreLenFuncCall) Args() []interface{} { + return []interface{}{} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c LoginSourceFilesStoreLenFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// LoginSourceFilesStoreListFunc describes the behavior when the List method +// of the parent MockLoginSourceFilesStore instance is invoked. +type LoginSourceFilesStoreListFunc struct { + defaultHook func(ListLoginSourceOpts) []*LoginSource + hooks []func(ListLoginSourceOpts) []*LoginSource + history []LoginSourceFilesStoreListFuncCall + 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 *MockLoginSourceFilesStore) List(v0 ListLoginSourceOpts) []*LoginSource { + r0 := m.ListFunc.nextHook()(v0) + m.ListFunc.appendCall(LoginSourceFilesStoreListFuncCall{v0, r0}) + return r0 +} + +// SetDefaultHook sets function that is called when the List method of the +// parent MockLoginSourceFilesStore instance is invoked and the hook queue +// is empty. +func (f *LoginSourceFilesStoreListFunc) SetDefaultHook(hook func(ListLoginSourceOpts) []*LoginSource) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// List method of the parent MockLoginSourceFilesStore 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 *LoginSourceFilesStoreListFunc) PushHook(hook func(ListLoginSourceOpts) []*LoginSource) { + 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 *LoginSourceFilesStoreListFunc) SetDefaultReturn(r0 []*LoginSource) { + f.SetDefaultHook(func(ListLoginSourceOpts) []*LoginSource { + return r0 + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *LoginSourceFilesStoreListFunc) PushReturn(r0 []*LoginSource) { + f.PushHook(func(ListLoginSourceOpts) []*LoginSource { + return r0 + }) +} + +func (f *LoginSourceFilesStoreListFunc) nextHook() func(ListLoginSourceOpts) []*LoginSource { + 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 *LoginSourceFilesStoreListFunc) appendCall(r0 LoginSourceFilesStoreListFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of LoginSourceFilesStoreListFuncCall objects +// describing the invocations of this function. +func (f *LoginSourceFilesStoreListFunc) History() []LoginSourceFilesStoreListFuncCall { + f.mutex.Lock() + history := make([]LoginSourceFilesStoreListFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// LoginSourceFilesStoreListFuncCall is an object that describes an +// invocation of method List on an instance of MockLoginSourceFilesStore. +type LoginSourceFilesStoreListFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 ListLoginSourceOpts + // Result0 is the value of the 1st result returned from this method + // invocation. + Result0 []*LoginSource +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c LoginSourceFilesStoreListFuncCall) Args() []interface{} { + return []interface{}{c.Arg0} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c LoginSourceFilesStoreListFuncCall) Results() []interface{} { + return []interface{}{c.Result0} +} + +// LoginSourceFilesStoreUpdateFunc describes the behavior when the Update +// method of the parent MockLoginSourceFilesStore instance is invoked. +type LoginSourceFilesStoreUpdateFunc struct { + defaultHook func(*LoginSource) + hooks []func(*LoginSource) + history []LoginSourceFilesStoreUpdateFuncCall + mutex sync.Mutex +} + +// Update delegates to the next hook function in the queue and stores the +// parameter and result values of this invocation. +func (m *MockLoginSourceFilesStore) Update(v0 *LoginSource) { + m.UpdateFunc.nextHook()(v0) + m.UpdateFunc.appendCall(LoginSourceFilesStoreUpdateFuncCall{v0}) + return +} + +// SetDefaultHook sets function that is called when the Update method of the +// parent MockLoginSourceFilesStore instance is invoked and the hook queue +// is empty. +func (f *LoginSourceFilesStoreUpdateFunc) SetDefaultHook(hook func(*LoginSource)) { + f.defaultHook = hook +} + +// PushHook adds a function to the end of hook queue. Each invocation of the +// Update method of the parent MockLoginSourceFilesStore 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 *LoginSourceFilesStoreUpdateFunc) PushHook(hook func(*LoginSource)) { + 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 *LoginSourceFilesStoreUpdateFunc) SetDefaultReturn() { + f.SetDefaultHook(func(*LoginSource) { + return + }) +} + +// PushReturn calls PushHook with a function that returns the given values. +func (f *LoginSourceFilesStoreUpdateFunc) PushReturn() { + f.PushHook(func(*LoginSource) { + return + }) +} + +func (f *LoginSourceFilesStoreUpdateFunc) nextHook() func(*LoginSource) { + 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 *LoginSourceFilesStoreUpdateFunc) appendCall(r0 LoginSourceFilesStoreUpdateFuncCall) { + f.mutex.Lock() + f.history = append(f.history, r0) + f.mutex.Unlock() +} + +// History returns a sequence of LoginSourceFilesStoreUpdateFuncCall objects +// describing the invocations of this function. +func (f *LoginSourceFilesStoreUpdateFunc) History() []LoginSourceFilesStoreUpdateFuncCall { + f.mutex.Lock() + history := make([]LoginSourceFilesStoreUpdateFuncCall, len(f.history)) + copy(history, f.history) + f.mutex.Unlock() + + return history +} + +// LoginSourceFilesStoreUpdateFuncCall is an object that describes an +// invocation of method Update on an instance of MockLoginSourceFilesStore. +type LoginSourceFilesStoreUpdateFuncCall struct { + // Arg0 is the value of the 1st argument passed to this method + // invocation. + Arg0 *LoginSource +} + +// Args returns an interface slice containing the arguments of this +// invocation. +func (c LoginSourceFilesStoreUpdateFuncCall) Args() []interface{} { + return []interface{}{c.Arg0} +} + +// Results returns an interface slice containing the results of this +// invocation. +func (c LoginSourceFilesStoreUpdateFuncCall) Results() []interface{} { + return []interface{}{} +} -- cgit v1.2.3