/*

* Copyright 2024 The CNAI Authors

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

// Code generated by mockery v2.53.3. DO NOT EDIT.

package backend

import (

backend "github.com/modelpack/modctl/pkg/backend"

config "github.com/modelpack/modctl/pkg/config"

context "context"

mock "github.com/stretchr/testify/mock"

)

// Backend is an autogenerated mock type for the Backend type

type Backend struct {

mock.Mock

}

type Backend_Expecter struct {

mock *mock.Mock

}

func (_m *Backend) EXPECT() *Backend_Expecter {

return &Backend_Expecter{mock: &_m.Mock}

}

// Attach provides a mock function with given fields: ctx, filepath, cfg

func (_m *Backend) Attach(ctx context.Context, filepath string, cfg *config.Attach) error {

ret := _m.Called(ctx, filepath, cfg)

if len(ret) == 0 {

panic("no return value specified for Attach")

}

var r0 error

if rf, ok := ret.Get(0).(func(context.Context, string, *config.Attach) error); ok {

r0 = rf(ctx, filepath, cfg)

} else {

r0 = ret.Error(0)

}

return r0

}

// Backend_Attach_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Attach'

type Backend_Attach_Call struct {

*mock.Call

}

// Attach is a helper method to define mock.On call

// - ctx context.Context

// - filepath string

// - cfg *config.Attach

func (_e *Backend_Expecter) Attach(ctx interface{}, filepath interface{}, cfg interface{}) *Backend_Attach_Call {

return &Backend_Attach_Call{Call: _e.mock.On("Attach", ctx, filepath, cfg)}

}

func (_c *Backend_Attach_Call) Run(run func(ctx context.Context, filepath string, cfg *config.Attach)) *Backend_Attach_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context), args[1].(string), args[2].(*config.Attach))

})

return _c

}

func (_c *Backend_Attach_Call) Return(_a0 error) *Backend_Attach_Call {

_c.Call.Return(_a0)

return _c

}

func (_c *Backend_Attach_Call) RunAndReturn(run func(context.Context, string, *config.Attach) error) *Backend_Attach_Call {

_c.Call.Return(run)

return _c

}

// Build provides a mock function with given fields: ctx, modelfilePath, workDir, target, cfg

func (_m *Backend) Build(ctx context.Context, modelfilePath string, workDir string, target string, cfg *config.Build) error {

ret := _m.Called(ctx, modelfilePath, workDir, target, cfg)

if len(ret) == 0 {

panic("no return value specified for Build")

}

var r0 error

if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *config.Build) error); ok {

r0 = rf(ctx, modelfilePath, workDir, target, cfg)

} else {

r0 = ret.Error(0)

}

return r0

}

// Backend_Build_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Build'

type Backend_Build_Call struct {

*mock.Call

}

// Build is a helper method to define mock.On call

// - ctx context.Context

// - modelfilePath string

// - workDir string

// - target string

// - cfg *config.Build

func (_e *Backend_Expecter) Build(ctx interface{}, modelfilePath interface{}, workDir interface{}, target interface{}, cfg interface{}) *Backend_Build_Call {

return &Backend_Build_Call{Call: _e.mock.On("Build", ctx, modelfilePath, workDir, target, cfg)}

}

func (_c *Backend_Build_Call) Run(run func(ctx context.Context, modelfilePath string, workDir string, target string, cfg *config.Build)) *Backend_Build_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*config.Build))

})

return _c

}

func (_c *Backend_Build_Call) Return(_a0 error) *Backend_Build_Call {

_c.Call.Return(_a0)

return _c

}

func (_c *Backend_Build_Call) RunAndReturn(run func(context.Context, string, string, string, *config.Build) error) *Backend_Build_Call {

_c.Call.Return(run)

return _c

}

// Extract provides a mock function with given fields: ctx, target, cfg

func (_m *Backend) Extract(ctx context.Context, target string, cfg *config.Extract) error {

ret := _m.Called(ctx, target, cfg)

if len(ret) == 0 {

panic("no return value specified for Extract")

}

var r0 error

if rf, ok := ret.Get(0).(func(context.Context, string, *config.Extract) error); ok {

r0 = rf(ctx, target, cfg)

} else {

r0 = ret.Error(0)

}

return r0

}

// Backend_Extract_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Extract'

type Backend_Extract_Call struct {

*mock.Call

}

// Extract is a helper method to define mock.On call

// - ctx context.Context

// - target string

// - cfg *config.Extract

func (_e *Backend_Expecter) Extract(ctx interface{}, target interface{}, cfg interface{}) *Backend_Extract_Call {

return &Backend_Extract_Call{Call: _e.mock.On("Extract", ctx, target, cfg)}

}

func (_c *Backend_Extract_Call) Run(run func(ctx context.Context, target string, cfg *config.Extract)) *Backend_Extract_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context), args[1].(string), args[2].(*config.Extract))

})

return _c

}

func (_c *Backend_Extract_Call) Return(_a0 error) *Backend_Extract_Call {

_c.Call.Return(_a0)

return _c

}

func (_c *Backend_Extract_Call) RunAndReturn(run func(context.Context, string, *config.Extract) error) *Backend_Extract_Call {

_c.Call.Return(run)

return _c

}

// Fetch provides a mock function with given fields: ctx, target, cfg

func (_m *Backend) Fetch(ctx context.Context, target string, cfg *config.Fetch) error {

ret := _m.Called(ctx, target, cfg)

if len(ret) == 0 {

panic("no return value specified for Fetch")

}

var r0 error

if rf, ok := ret.Get(0).(func(context.Context, string, *config.Fetch) error); ok {

r0 = rf(ctx, target, cfg)

} else {

r0 = ret.Error(0)

}

return r0

}

// Backend_Fetch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Fetch'

type Backend_Fetch_Call struct {

*mock.Call

}

// Fetch is a helper method to define mock.On call

// - ctx context.Context

// - target string

// - cfg *config.Fetch

func (_e *Backend_Expecter) Fetch(ctx interface{}, target interface{}, cfg interface{}) *Backend_Fetch_Call {

return &Backend_Fetch_Call{Call: _e.mock.On("Fetch", ctx, target, cfg)}

}

func (_c *Backend_Fetch_Call) Run(run func(ctx context.Context, target string, cfg *config.Fetch)) *Backend_Fetch_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context), args[1].(string), args[2].(*config.Fetch))

})

return _c

}

func (_c *Backend_Fetch_Call) Return(_a0 error) *Backend_Fetch_Call {

_c.Call.Return(_a0)

return _c

}

func (_c *Backend_Fetch_Call) RunAndReturn(run func(context.Context, string, *config.Fetch) error) *Backend_Fetch_Call {

_c.Call.Return(run)

return _c

}

// Inspect provides a mock function with given fields: ctx, target, cfg

func (_m *Backend) Inspect(ctx context.Context, target string, cfg *config.Inspect) (interface{}, error) {

ret := _m.Called(ctx, target, cfg)

if len(ret) == 0 {

panic("no return value specified for Inspect")

}

var r0 interface{}

var r1 error

if rf, ok := ret.Get(0).(func(context.Context, string, *config.Inspect) (interface{}, error)); ok {

return rf(ctx, target, cfg)

}

if rf, ok := ret.Get(0).(func(context.Context, string, *config.Inspect) interface{}); ok {

r0 = rf(ctx, target, cfg)

} else {

if ret.Get(0) != nil {

r0 = ret.Get(0).(interface{})

}

}

if rf, ok := ret.Get(1).(func(context.Context, string, *config.Inspect) error); ok {

r1 = rf(ctx, target, cfg)

} else {

r1 = ret.Error(1)

}

return r0, r1

}

// Backend_Inspect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Inspect'

type Backend_Inspect_Call struct {

*mock.Call

}

// Inspect is a helper method to define mock.On call

// - ctx context.Context

// - target string

// - cfg *config.Inspect

func (_e *Backend_Expecter) Inspect(ctx interface{}, target interface{}, cfg interface{}) *Backend_Inspect_Call {

return &Backend_Inspect_Call{Call: _e.mock.On("Inspect", ctx, target, cfg)}

}

func (_c *Backend_Inspect_Call) Run(run func(ctx context.Context, target string, cfg *config.Inspect)) *Backend_Inspect_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context), args[1].(string), args[2].(*config.Inspect))

})

return _c

}

func (_c *Backend_Inspect_Call) Return(_a0 interface{}, _a1 error) *Backend_Inspect_Call {

_c.Call.Return(_a0, _a1)

return _c

}

func (_c *Backend_Inspect_Call) RunAndReturn(run func(context.Context, string, *config.Inspect) (interface{}, error)) *Backend_Inspect_Call {

_c.Call.Return(run)

return _c

}

// List provides a mock function with given fields: ctx

func (_m *Backend) List(ctx context.Context) ([]*backend.ModelArtifact, error) {

ret := _m.Called(ctx)

if len(ret) == 0 {

panic("no return value specified for List")

}

var r0 []*backend.ModelArtifact

var r1 error

if rf, ok := ret.Get(0).(func(context.Context) ([]*backend.ModelArtifact, error)); ok {

return rf(ctx)

}

if rf, ok := ret.Get(0).(func(context.Context) []*backend.ModelArtifact); ok {

r0 = rf(ctx)

} else {

if ret.Get(0) != nil {

r0 = ret.Get(0).([]*backend.ModelArtifact)

}

}

if rf, ok := ret.Get(1).(func(context.Context) error); ok {

r1 = rf(ctx)

} else {

r1 = ret.Error(1)

}

return r0, r1

}

// Backend_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'

type Backend_List_Call struct {

*mock.Call

}

// List is a helper method to define mock.On call

// - ctx context.Context

func (_e *Backend_Expecter) List(ctx interface{}) *Backend_List_Call {

return &Backend_List_Call{Call: _e.mock.On("List", ctx)}

}

func (_c *Backend_List_Call) Run(run func(ctx context.Context)) *Backend_List_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context))

})

return _c

}

func (_c *Backend_List_Call) Return(_a0 []*backend.ModelArtifact, _a1 error) *Backend_List_Call {

_c.Call.Return(_a0, _a1)

return _c

}

func (_c *Backend_List_Call) RunAndReturn(run func(context.Context) ([]*backend.ModelArtifact, error)) *Backend_List_Call {

_c.Call.Return(run)

return _c

}

// Login provides a mock function with given fields: ctx, registry, username, password, cfg

func (_m *Backend) Login(ctx context.Context, registry string, username string, password string, cfg *config.Login) error {

ret := _m.Called(ctx, registry, username, password, cfg)

if len(ret) == 0 {

panic("no return value specified for Login")

}

var r0 error

if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *config.Login) error); ok {

r0 = rf(ctx, registry, username, password, cfg)

} else {

r0 = ret.Error(0)

}

return r0

}

// Backend_Login_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Login'

type Backend_Login_Call struct {

*mock.Call

}

// Login is a helper method to define mock.On call

// - ctx context.Context

// - registry string

// - username string

// - password string

// - cfg *config.Login

func (_e *Backend_Expecter) Login(ctx interface{}, registry interface{}, username interface{}, password interface{}, cfg interface{}) *Backend_Login_Call {

return &Backend_Login_Call{Call: _e.mock.On("Login", ctx, registry, username, password, cfg)}

}

func (_c *Backend_Login_Call) Run(run func(ctx context.Context, registry string, username string, password string, cfg *config.Login)) *Backend_Login_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*config.Login))

})

return _c

}

func (_c *Backend_Login_Call) Return(_a0 error) *Backend_Login_Call {

_c.Call.Return(_a0)

return _c

}

func (_c *Backend_Login_Call) RunAndReturn(run func(context.Context, string, string, string, *config.Login) error) *Backend_Login_Call {

_c.Call.Return(run)

return _c

}

// Logout provides a mock function with given fields: ctx, registry

func (_m *Backend) Logout(ctx context.Context, registry string) error {

ret := _m.Called(ctx, registry)

if len(ret) == 0 {

panic("no return value specified for Logout")

}

var r0 error

if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {

r0 = rf(ctx, registry)

} else {

r0 = ret.Error(0)

}

return r0

}

// Backend_Logout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Logout'

type Backend_Logout_Call struct {

*mock.Call

}

// Logout is a helper method to define mock.On call

// - ctx context.Context

// - registry string

func (_e *Backend_Expecter) Logout(ctx interface{}, registry interface{}) *Backend_Logout_Call {

return &Backend_Logout_Call{Call: _e.mock.On("Logout", ctx, registry)}

}

func (_c *Backend_Logout_Call) Run(run func(ctx context.Context, registry string)) *Backend_Logout_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context), args[1].(string))

})

return _c

}

func (_c *Backend_Logout_Call) Return(_a0 error) *Backend_Logout_Call {

_c.Call.Return(_a0)

return _c

}

func (_c *Backend_Logout_Call) RunAndReturn(run func(context.Context, string) error) *Backend_Logout_Call {

_c.Call.Return(run)

return _c

}

// Prune provides a mock function with given fields: ctx, dryRun, removeUntagged

func (_m *Backend) Prune(ctx context.Context, dryRun bool, removeUntagged bool) error {

ret := _m.Called(ctx, dryRun, removeUntagged)

if len(ret) == 0 {

panic("no return value specified for Prune")

}

var r0 error

if rf, ok := ret.Get(0).(func(context.Context, bool, bool) error); ok {

r0 = rf(ctx, dryRun, removeUntagged)

} else {

r0 = ret.Error(0)

}

return r0

}

// Backend_Prune_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Prune'

type Backend_Prune_Call struct {

*mock.Call

}

// Prune is a helper method to define mock.On call

// - ctx context.Context

// - dryRun bool

// - removeUntagged bool

func (_e *Backend_Expecter) Prune(ctx interface{}, dryRun interface{}, removeUntagged interface{}) *Backend_Prune_Call {

return &Backend_Prune_Call{Call: _e.mock.On("Prune", ctx, dryRun, removeUntagged)}

}

func (_c *Backend_Prune_Call) Run(run func(ctx context.Context, dryRun bool, removeUntagged bool)) *Backend_Prune_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context), args[1].(bool), args[2].(bool))

})

return _c

}

func (_c *Backend_Prune_Call) Return(_a0 error) *Backend_Prune_Call {

_c.Call.Return(_a0)

return _c

}

func (_c *Backend_Prune_Call) RunAndReturn(run func(context.Context, bool, bool) error) *Backend_Prune_Call {

_c.Call.Return(run)

return _c

}

// Pull provides a mock function with given fields: ctx, target, cfg

func (_m *Backend) Pull(ctx context.Context, target string, cfg *config.Pull) error {

ret := _m.Called(ctx, target, cfg)

if len(ret) == 0 {

panic("no return value specified for Pull")

}

var r0 error

if rf, ok := ret.Get(0).(func(context.Context, string, *config.Pull) error); ok {

r0 = rf(ctx, target, cfg)

} else {

r0 = ret.Error(0)

}

return r0

}

// Backend_Pull_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Pull'

type Backend_Pull_Call struct {

*mock.Call

}

// Pull is a helper method to define mock.On call

// - ctx context.Context

// - target string

// - cfg *config.Pull

func (_e *Backend_Expecter) Pull(ctx interface{}, target interface{}, cfg interface{}) *Backend_Pull_Call {

return &Backend_Pull_Call{Call: _e.mock.On("Pull", ctx, target, cfg)}

}

func (_c *Backend_Pull_Call) Run(run func(ctx context.Context, target string, cfg *config.Pull)) *Backend_Pull_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context), args[1].(string), args[2].(*config.Pull))

})

return _c

}

func (_c *Backend_Pull_Call) Return(_a0 error) *Backend_Pull_Call {

_c.Call.Return(_a0)

return _c

}

func (_c *Backend_Pull_Call) RunAndReturn(run func(context.Context, string, *config.Pull) error) *Backend_Pull_Call {

_c.Call.Return(run)

return _c

}

// Push provides a mock function with given fields: ctx, target, cfg

func (_m *Backend) Push(ctx context.Context, target string, cfg *config.Push) error {

ret := _m.Called(ctx, target, cfg)

if len(ret) == 0 {

panic("no return value specified for Push")

}

var r0 error

if rf, ok := ret.Get(0).(func(context.Context, string, *config.Push) error); ok {

r0 = rf(ctx, target, cfg)

} else {

r0 = ret.Error(0)

}

return r0

}

// Backend_Push_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Push'

type Backend_Push_Call struct {

*mock.Call

}

// Push is a helper method to define mock.On call

// - ctx context.Context

// - target string

// - cfg *config.Push

func (_e *Backend_Expecter) Push(ctx interface{}, target interface{}, cfg interface{}) *Backend_Push_Call {

return &Backend_Push_Call{Call: _e.mock.On("Push", ctx, target, cfg)}

}

func (_c *Backend_Push_Call) Run(run func(ctx context.Context, target string, cfg *config.Push)) *Backend_Push_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context), args[1].(string), args[2].(*config.Push))

})

return _c

}

func (_c *Backend_Push_Call) Return(_a0 error) *Backend_Push_Call {

_c.Call.Return(_a0)

return _c

}

func (_c *Backend_Push_Call) RunAndReturn(run func(context.Context, string, *config.Push) error) *Backend_Push_Call {

_c.Call.Return(run)

return _c

}

// Remove provides a mock function with given fields: ctx, target

func (_m *Backend) Remove(ctx context.Context, target string) (string, error) {

ret := _m.Called(ctx, target)

if len(ret) == 0 {

panic("no return value specified for Remove")

}

var r0 string

var r1 error

if rf, ok := ret.Get(0).(func(context.Context, string) (string, error)); ok {

return rf(ctx, target)

}

if rf, ok := ret.Get(0).(func(context.Context, string) string); ok {

r0 = rf(ctx, target)

} else {

r0 = ret.Get(0).(string)

}

if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {

r1 = rf(ctx, target)

} else {

r1 = ret.Error(1)

}

return r0, r1

}

// Backend_Remove_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Remove'

type Backend_Remove_Call struct {

*mock.Call

}

// Remove is a helper method to define mock.On call

// - ctx context.Context

// - target string

func (_e *Backend_Expecter) Remove(ctx interface{}, target interface{}) *Backend_Remove_Call {

return &Backend_Remove_Call{Call: _e.mock.On("Remove", ctx, target)}

}

func (_c *Backend_Remove_Call) Run(run func(ctx context.Context, target string)) *Backend_Remove_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context), args[1].(string))

})

return _c

}

func (_c *Backend_Remove_Call) Return(_a0 string, _a1 error) *Backend_Remove_Call {

_c.Call.Return(_a0, _a1)

return _c

}

func (_c *Backend_Remove_Call) RunAndReturn(run func(context.Context, string) (string, error)) *Backend_Remove_Call {

_c.Call.Return(run)

return _c

}

// Tag provides a mock function with given fields: ctx, source, target

func (_m *Backend) Tag(ctx context.Context, source string, target string) error {

ret := _m.Called(ctx, source, target)

if len(ret) == 0 {

panic("no return value specified for Tag")

}

var r0 error

if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {

r0 = rf(ctx, source, target)

} else {

r0 = ret.Error(0)

}

return r0

}

// Backend_Tag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Tag'

type Backend_Tag_Call struct {

*mock.Call

}

// Tag is a helper method to define mock.On call

// - ctx context.Context

// - source string

// - target string

func (_e *Backend_Expecter) Tag(ctx interface{}, source interface{}, target interface{}) *Backend_Tag_Call {

return &Backend_Tag_Call{Call: _e.mock.On("Tag", ctx, source, target)}

}

func (_c *Backend_Tag_Call) Run(run func(ctx context.Context, source string, target string)) *Backend_Tag_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context), args[1].(string), args[2].(string))

})

return _c

}

func (_c *Backend_Tag_Call) Return(_a0 error) *Backend_Tag_Call {

_c.Call.Return(_a0)

return _c

}

func (_c *Backend_Tag_Call) RunAndReturn(run func(context.Context, string, string) error) *Backend_Tag_Call {

_c.Call.Return(run)

return _c

}

// Upload provides a mock function with given fields: ctx, filepath, cfg

func (_m *Backend) Upload(ctx context.Context, filepath string, cfg *config.Upload) error {

ret := _m.Called(ctx, filepath, cfg)

if len(ret) == 0 {

panic("no return value specified for Upload")

}

var r0 error

if rf, ok := ret.Get(0).(func(context.Context, string, *config.Upload) error); ok {

r0 = rf(ctx, filepath, cfg)

} else {

r0 = ret.Error(0)

}

return r0

}

// Backend_Upload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upload'

type Backend_Upload_Call struct {

*mock.Call

}

// Upload is a helper method to define mock.On call

// - ctx context.Context

// - filepath string

// - cfg *config.Upload

func (_e *Backend_Expecter) Upload(ctx interface{}, filepath interface{}, cfg interface{}) *Backend_Upload_Call {

return &Backend_Upload_Call{Call: _e.mock.On("Upload", ctx, filepath, cfg)}

}

func (_c *Backend_Upload_Call) Run(run func(ctx context.Context, filepath string, cfg *config.Upload)) *Backend_Upload_Call {

_c.Call.Run(func(args mock.Arguments) {

run(args[0].(context.Context), args[1].(string), args[2].(*config.Upload))

})

return _c

}

func (_c *Backend_Upload_Call) Return(_a0 error) *Backend_Upload_Call {

_c.Call.Return(_a0)

return _c

}

func (_c *Backend_Upload_Call) RunAndReturn(run func(context.Context, string, *config.Upload) error) *Backend_Upload_Call {

_c.Call.Return(run)

return _c

}

// NewBackend creates a new instance of Backend. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

// The first argument is typically a *testing.T value.

func NewBackend(t interface {

mock.TestingT

Cleanup(func())

}) *Backend {

mock := &Backend{}

mock.Mock.Test(t)

t.Cleanup(func() { mock.AssertExpectations(t) })

return mock

}