+ "context"

+ CreateObject(ctx context.Context, repoID int64, oid lfsutil.OID, size int64, storage lfsutil.Storage) error

+ // GetObjectByOID returns the LFS object with given OID. It returns

+ // ErrLFSObjectNotExist when not found.

+ GetObjectByOID(ctx context.Context, repoID int64, oid lfsutil.OID) (*LFSObject, error)

+ // GetObjectsByOIDs returns LFS objects found within "oids". The returned list

+ // could have less elements if some oids were not found.

+ GetObjectsByOIDs(ctx context.Context, repoID int64, oids ...lfsutil.OID) ([]*LFSObject, error)

+ RepoID int64 `gorm:"primary_key;auto_increment:false"`

+ OID lfsutil.OID `gorm:"primary_key;column:oid"`

+ Size int64 `gorm:"not null"`

+ Storage lfsutil.Storage `gorm:"not null"`

+ CreatedAt time.Time `gorm:"not null"`

+func (db *lfs) CreateObject(ctx context.Context, repoID int64, oid lfsutil.OID, size int64, storage lfsutil.Storage) error {

+ return db.WithContext(ctx).Create(object).Error

+func (db *lfs) GetObjectByOID(ctx context.Context, repoID int64, oid lfsutil.OID) (*LFSObject, error) {

+ err := db.WithContext(ctx).Where("repo_id = ? AND oid = ?", repoID, oid).First(object).Error

+func (db *lfs) GetObjectsByOIDs(ctx context.Context, repoID int64, oids ...lfsutil.OID) ([]*LFSObject, error) {

+ err := db.WithContext(ctx).Where("repo_id = ? AND oid IN (?)", repoID, oids).Find(&objects).Error

+ "context"

+ "github.com/stretchr/testify/require"

+func TestLFS(t *testing.T) {

+ {"CreateObject", lfsCreateObject},

+ {"GetObjectByOID", lfsGetObjectByOID},

+ {"GetObjectsByOIDs", lfsGetObjectsByOIDs},

+ require.NoError(t, err)

+func lfsCreateObject(t *testing.T, db *lfs) {

+ ctx := context.Background()

+

+ err := db.CreateObject(ctx, repoID, oid, 12, lfsutil.StorageLocal)

+ require.NoError(t, err)

+ object, err := db.GetObjectByOID(ctx, repoID, oid)

+ require.NoError(t, err)

+ err = db.CreateObject(ctx, repoID, oid, 12, lfsutil.StorageLocal)

+func lfsGetObjectByOID(t *testing.T, db *lfs) {

+ ctx := context.Background()

+

+ err := db.CreateObject(ctx, repoID, oid, 12, lfsutil.StorageLocal)

+ require.NoError(t, err)

+ _, err = db.GetObjectByOID(ctx, repoID, oid)

+ require.NoError(t, err)

+ _, err = db.GetObjectByOID(ctx, repoID, "bad_oid")

+func lfsGetObjectsByOIDs(t *testing.T, db *lfs) {

+ ctx := context.Background()

+

+ err := db.CreateObject(ctx, repoID, oid1, 12, lfsutil.StorageLocal)

+ require.NoError(t, err)

+ err = db.CreateObject(ctx, repoID, oid2, 12, lfsutil.StorageLocal)

+ require.NoError(t, err)

+ objects, err := db.GetObjectsByOIDs(ctx, repoID, oid1, oid2, "bad_oid")

+ require.NoError(t, err)

+//go:generate go-mockgen -f gogs.io/gogs/internal/db -i AccessTokensStore -i LFSStore -i PermsStore -o mocks.go

+

+ lfsutil "gogs.io/gogs/internal/lfsutil"

+// 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 *LFSObject, r1 error) {

+ return

+ },

+ },

+ GetObjectsByOIDsFunc: &LFSStoreGetObjectsByOIDsFunc{

+ defaultHook: func(context.Context, int64, ...lfsutil.OID) (r0 []*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) (*LFSObject, error) {

+ panic("unexpected invocation of MockLFSStore.GetObjectByOID")

+ },

+ },

+ GetObjectsByOIDsFunc: &LFSStoreGetObjectsByOIDsFunc{

+ defaultHook: func(context.Context, int64, ...lfsutil.OID) ([]*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 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) (*LFSObject, error)

+ hooks []func(context.Context, int64, lfsutil.OID) (*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) (*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) (*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) (*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 *LFSObject, r1 error) {

+ f.SetDefaultHook(func(context.Context, int64, lfsutil.OID) (*LFSObject, error) {

+ return r0, r1

+ })

+}

+

+// PushReturn calls PushHook with a function that returns the given values.

+func (f *LFSStoreGetObjectByOIDFunc) PushReturn(r0 *LFSObject, r1 error) {

+ f.PushHook(func(context.Context, int64, lfsutil.OID) (*LFSObject, error) {

+ return r0, r1

+ })

+}

+

+func (f *LFSStoreGetObjectByOIDFunc) nextHook() func(context.Context, int64, lfsutil.OID) (*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 *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) ([]*LFSObject, error)

+ hooks []func(context.Context, int64, ...lfsutil.OID) ([]*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) ([]*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) ([]*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) ([]*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 []*LFSObject, r1 error) {

+ f.SetDefaultHook(func(context.Context, int64, ...lfsutil.OID) ([]*LFSObject, error) {

+ return r0, r1

+ })

+}

+

+// PushReturn calls PushHook with a function that returns the given values.

+func (f *LFSStoreGetObjectsByOIDsFunc) PushReturn(r0 []*LFSObject, r1 error) {

+ f.PushHook(func(context.Context, int64, ...lfsutil.OID) ([]*LFSObject, error) {

+ return r0, r1

+ })

+}

+

+func (f *LFSStoreGetObjectsByOIDsFunc) nextHook() func(context.Context, int64, ...lfsutil.OID) ([]*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 []*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}

+}

+

+ object, err := db.LFS.GetObjectByOID(c.Req.Context(), repo.ID, oid)

+ _, err := db.LFS.GetObjectByOID(c.Req.Context(), repo.ID, oid)

+ err = db.LFS.CreateObject(c.Req.Context(), repo.ID, oid, written, s.Storage())

+ object, err := db.LFS.GetObjectByOID(c.Req.Context(), repo.ID, request.Oid)

+ mockLFSStore func() db.LFSStore

+ mockLFSStore: func() db.LFSStore {

+ mock := db.NewMockLFSStore()

+ mock.GetObjectByOIDFunc.SetDefaultReturn(nil, db.ErrLFSObjectNotExist{})

+ return mock

+ mockLFSStore: func() db.LFSStore {

+ mock := db.NewMockLFSStore()

+ mock.GetObjectByOIDFunc.SetDefaultReturn(&db.LFSObject{Storage: "bad_storage"}, nil)

+ return mock

+ mockLFSStore: func() db.LFSStore {

+ mock := db.NewMockLFSStore()

+ mock.GetObjectByOIDFunc.SetDefaultReturn(

+ &db.LFSObject{

+ },

+ nil,

+ )

+ return mock

+ db.SetMockLFSStore(t, test.mockLFSStore())

+ mockLFSStore func() db.LFSStore

+ mockLFSStore: func() db.LFSStore {

+ mock := db.NewMockLFSStore()

+ mock.GetObjectByOIDFunc.SetDefaultReturn(&db.LFSObject{}, nil)

+ return mock

+ mockLFSStore: func() db.LFSStore {

+ mock := db.NewMockLFSStore()

+ mock.GetObjectByOIDFunc.SetDefaultReturn(nil, db.ErrLFSObjectNotExist{})

+ return mock

+ db.SetMockLFSStore(t, test.mockLFSStore())

+ mockLFSStore func() db.LFSStore

+ mockLFSStore: func() db.LFSStore {

+ mock := db.NewMockLFSStore()

+ mock.GetObjectByOIDFunc.SetDefaultReturn(nil, db.ErrLFSObjectNotExist{})

+ return mock

+ mockLFSStore: func() db.LFSStore {

+ mock := db.NewMockLFSStore()

+ mock.GetObjectByOIDFunc.SetDefaultReturn(&db.LFSObject{Size: 12}, nil)

+ return mock

+ mockLFSStore: func() db.LFSStore {

+ mock := db.NewMockLFSStore()

+ mock.GetObjectByOIDFunc.SetDefaultReturn(&db.LFSObject{Size: 12}, nil)

+ return mock

+ if test.mockLFSStore != nil {

+ db.SetMockLFSStore(t, test.mockLFSStore())

+ }

+ stored, err := db.LFS.GetObjectsByOIDs(c.Req.Context(), repo.ID, oids...)

+ mockLFSStore func() db.LFSStore

+ mockLFSStore: func() db.LFSStore {

+ mock := db.NewMockLFSStore()

+ mock.GetObjectsByOIDsFunc.SetDefaultReturn(

+ []*db.LFSObject{

+ },

+ nil,

+ )

+ return mock

+ if test.mockLFSStore != nil {

+ db.SetMockLFSStore(t, test.mockLFSStore())

+ }