mirror of
https://github.com/vmware-tanzu/velero.git
synced 2026-09-28 10:45:44 +00:00
1084 lines
32 KiB
Go
1084 lines
32 KiB
Go
// Code generated by mockery; DO NOT EDIT.
|
|
// github.com/vektra/mockery
|
|
// template: testify
|
|
|
|
package mocks
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
mock "github.com/stretchr/testify/mock"
|
|
"github.com/vmware-tanzu/velero/pkg/repository/udmrepo"
|
|
)
|
|
|
|
// NewBackupRepo creates a new instance of BackupRepo. 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 NewBackupRepo(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *BackupRepo {
|
|
mock := &BackupRepo{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|
|
|
|
// BackupRepo is an autogenerated mock type for the BackupRepo type
|
|
type BackupRepo struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type BackupRepo_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *BackupRepo) EXPECT() *BackupRepo_Expecter {
|
|
return &BackupRepo_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// Close provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) Close(ctx context.Context) error {
|
|
ret := _mock.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Close")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
|
|
r0 = returnFunc(ctx)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BackupRepo_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
|
|
type BackupRepo_Close_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Close is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *BackupRepo_Expecter) Close(ctx interface{}) *BackupRepo_Close_Call {
|
|
return &BackupRepo_Close_Call{Call: _e.mock.On("Close", ctx)}
|
|
}
|
|
|
|
func (_c *BackupRepo_Close_Call) Run(run func(ctx context.Context)) *BackupRepo_Close_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_Close_Call) Return(err error) *BackupRepo_Close_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_Close_Call) RunAndReturn(run func(ctx context.Context) error) *BackupRepo_Close_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ConcatenateObjects provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) ConcatenateObjects(ctx context.Context, objectIDs []udmrepo.ID) (udmrepo.ID, error) {
|
|
ret := _mock.Called(ctx, objectIDs)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ConcatenateObjects")
|
|
}
|
|
|
|
var r0 udmrepo.ID
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, []udmrepo.ID) (udmrepo.ID, error)); ok {
|
|
return returnFunc(ctx, objectIDs)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, []udmrepo.ID) udmrepo.ID); ok {
|
|
r0 = returnFunc(ctx, objectIDs)
|
|
} else {
|
|
r0 = ret.Get(0).(udmrepo.ID)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, []udmrepo.ID) error); ok {
|
|
r1 = returnFunc(ctx, objectIDs)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// BackupRepo_ConcatenateObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConcatenateObjects'
|
|
type BackupRepo_ConcatenateObjects_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ConcatenateObjects is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - objectIDs []udmrepo.ID
|
|
func (_e *BackupRepo_Expecter) ConcatenateObjects(ctx interface{}, objectIDs interface{}) *BackupRepo_ConcatenateObjects_Call {
|
|
return &BackupRepo_ConcatenateObjects_Call{Call: _e.mock.On("ConcatenateObjects", ctx, objectIDs)}
|
|
}
|
|
|
|
func (_c *BackupRepo_ConcatenateObjects_Call) Run(run func(ctx context.Context, objectIDs []udmrepo.ID)) *BackupRepo_ConcatenateObjects_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 []udmrepo.ID
|
|
if args[1] != nil {
|
|
arg1 = args[1].([]udmrepo.ID)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_ConcatenateObjects_Call) Return(iD udmrepo.ID, err error) *BackupRepo_ConcatenateObjects_Call {
|
|
_c.Call.Return(iD, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_ConcatenateObjects_Call) RunAndReturn(run func(ctx context.Context, objectIDs []udmrepo.ID) (udmrepo.ID, error)) *BackupRepo_ConcatenateObjects_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteManifest provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) DeleteManifest(ctx context.Context, id udmrepo.ID) error {
|
|
ret := _mock.Called(ctx, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteManifest")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) error); ok {
|
|
r0 = returnFunc(ctx, id)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BackupRepo_DeleteManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteManifest'
|
|
type BackupRepo_DeleteManifest_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteManifest is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - id udmrepo.ID
|
|
func (_e *BackupRepo_Expecter) DeleteManifest(ctx interface{}, id interface{}) *BackupRepo_DeleteManifest_Call {
|
|
return &BackupRepo_DeleteManifest_Call{Call: _e.mock.On("DeleteManifest", ctx, id)}
|
|
}
|
|
|
|
func (_c *BackupRepo_DeleteManifest_Call) Run(run func(ctx context.Context, id udmrepo.ID)) *BackupRepo_DeleteManifest_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 udmrepo.ID
|
|
if args[1] != nil {
|
|
arg1 = args[1].(udmrepo.ID)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_DeleteManifest_Call) Return(err error) *BackupRepo_DeleteManifest_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_DeleteManifest_Call) RunAndReturn(run func(ctx context.Context, id udmrepo.ID) error) *BackupRepo_DeleteManifest_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteSnapshot provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) DeleteSnapshot(ctx context.Context, id udmrepo.ID) error {
|
|
ret := _mock.Called(ctx, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteSnapshot")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) error); ok {
|
|
r0 = returnFunc(ctx, id)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BackupRepo_DeleteSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSnapshot'
|
|
type BackupRepo_DeleteSnapshot_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteSnapshot is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - id udmrepo.ID
|
|
func (_e *BackupRepo_Expecter) DeleteSnapshot(ctx interface{}, id interface{}) *BackupRepo_DeleteSnapshot_Call {
|
|
return &BackupRepo_DeleteSnapshot_Call{Call: _e.mock.On("DeleteSnapshot", ctx, id)}
|
|
}
|
|
|
|
func (_c *BackupRepo_DeleteSnapshot_Call) Run(run func(ctx context.Context, id udmrepo.ID)) *BackupRepo_DeleteSnapshot_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 udmrepo.ID
|
|
if args[1] != nil {
|
|
arg1 = args[1].(udmrepo.ID)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_DeleteSnapshot_Call) Return(err error) *BackupRepo_DeleteSnapshot_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_DeleteSnapshot_Call) RunAndReturn(run func(ctx context.Context, id udmrepo.ID) error) *BackupRepo_DeleteSnapshot_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// FindManifests provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) FindManifests(ctx context.Context, filter udmrepo.ManifestFilter) ([]*udmrepo.ManifestEntryMetadata, error) {
|
|
ret := _mock.Called(ctx, filter)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for FindManifests")
|
|
}
|
|
|
|
var r0 []*udmrepo.ManifestEntryMetadata
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ManifestFilter) ([]*udmrepo.ManifestEntryMetadata, error)); ok {
|
|
return returnFunc(ctx, filter)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ManifestFilter) []*udmrepo.ManifestEntryMetadata); ok {
|
|
r0 = returnFunc(ctx, filter)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*udmrepo.ManifestEntryMetadata)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.ManifestFilter) error); ok {
|
|
r1 = returnFunc(ctx, filter)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// BackupRepo_FindManifests_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindManifests'
|
|
type BackupRepo_FindManifests_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// FindManifests is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - filter udmrepo.ManifestFilter
|
|
func (_e *BackupRepo_Expecter) FindManifests(ctx interface{}, filter interface{}) *BackupRepo_FindManifests_Call {
|
|
return &BackupRepo_FindManifests_Call{Call: _e.mock.On("FindManifests", ctx, filter)}
|
|
}
|
|
|
|
func (_c *BackupRepo_FindManifests_Call) Run(run func(ctx context.Context, filter udmrepo.ManifestFilter)) *BackupRepo_FindManifests_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 udmrepo.ManifestFilter
|
|
if args[1] != nil {
|
|
arg1 = args[1].(udmrepo.ManifestFilter)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_FindManifests_Call) Return(manifestEntryMetadatas []*udmrepo.ManifestEntryMetadata, err error) *BackupRepo_FindManifests_Call {
|
|
_c.Call.Return(manifestEntryMetadatas, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_FindManifests_Call) RunAndReturn(run func(ctx context.Context, filter udmrepo.ManifestFilter) ([]*udmrepo.ManifestEntryMetadata, error)) *BackupRepo_FindManifests_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Flush provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) Flush(ctx context.Context) error {
|
|
ret := _mock.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Flush")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok {
|
|
r0 = returnFunc(ctx)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BackupRepo_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush'
|
|
type BackupRepo_Flush_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Flush is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *BackupRepo_Expecter) Flush(ctx interface{}) *BackupRepo_Flush_Call {
|
|
return &BackupRepo_Flush_Call{Call: _e.mock.On("Flush", ctx)}
|
|
}
|
|
|
|
func (_c *BackupRepo_Flush_Call) Run(run func(ctx context.Context)) *BackupRepo_Flush_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
run(
|
|
arg0,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_Flush_Call) Return(err error) *BackupRepo_Flush_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_Flush_Call) RunAndReturn(run func(ctx context.Context) error) *BackupRepo_Flush_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetAdvancedFeatures provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) GetAdvancedFeatures() udmrepo.AdvancedFeatureInfo {
|
|
ret := _mock.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetAdvancedFeatures")
|
|
}
|
|
|
|
var r0 udmrepo.AdvancedFeatureInfo
|
|
if returnFunc, ok := ret.Get(0).(func() udmrepo.AdvancedFeatureInfo); ok {
|
|
r0 = returnFunc()
|
|
} else {
|
|
r0 = ret.Get(0).(udmrepo.AdvancedFeatureInfo)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BackupRepo_GetAdvancedFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAdvancedFeatures'
|
|
type BackupRepo_GetAdvancedFeatures_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetAdvancedFeatures is a helper method to define mock.On call
|
|
func (_e *BackupRepo_Expecter) GetAdvancedFeatures() *BackupRepo_GetAdvancedFeatures_Call {
|
|
return &BackupRepo_GetAdvancedFeatures_Call{Call: _e.mock.On("GetAdvancedFeatures")}
|
|
}
|
|
|
|
func (_c *BackupRepo_GetAdvancedFeatures_Call) Run(run func()) *BackupRepo_GetAdvancedFeatures_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_GetAdvancedFeatures_Call) Return(advancedFeatureInfo udmrepo.AdvancedFeatureInfo) *BackupRepo_GetAdvancedFeatures_Call {
|
|
_c.Call.Return(advancedFeatureInfo)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_GetAdvancedFeatures_Call) RunAndReturn(run func() udmrepo.AdvancedFeatureInfo) *BackupRepo_GetAdvancedFeatures_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetManifest provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) GetManifest(ctx context.Context, id udmrepo.ID, mani *udmrepo.RepoManifest) error {
|
|
ret := _mock.Called(ctx, id, mani)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetManifest")
|
|
}
|
|
|
|
var r0 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID, *udmrepo.RepoManifest) error); ok {
|
|
r0 = returnFunc(ctx, id, mani)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BackupRepo_GetManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetManifest'
|
|
type BackupRepo_GetManifest_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetManifest is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - id udmrepo.ID
|
|
// - mani *udmrepo.RepoManifest
|
|
func (_e *BackupRepo_Expecter) GetManifest(ctx interface{}, id interface{}, mani interface{}) *BackupRepo_GetManifest_Call {
|
|
return &BackupRepo_GetManifest_Call{Call: _e.mock.On("GetManifest", ctx, id, mani)}
|
|
}
|
|
|
|
func (_c *BackupRepo_GetManifest_Call) Run(run func(ctx context.Context, id udmrepo.ID, mani *udmrepo.RepoManifest)) *BackupRepo_GetManifest_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 udmrepo.ID
|
|
if args[1] != nil {
|
|
arg1 = args[1].(udmrepo.ID)
|
|
}
|
|
var arg2 *udmrepo.RepoManifest
|
|
if args[2] != nil {
|
|
arg2 = args[2].(*udmrepo.RepoManifest)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_GetManifest_Call) Return(err error) *BackupRepo_GetManifest_Call {
|
|
_c.Call.Return(err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_GetManifest_Call) RunAndReturn(run func(ctx context.Context, id udmrepo.ID, mani *udmrepo.RepoManifest) error) *BackupRepo_GetManifest_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSnapshot provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) GetSnapshot(ctx context.Context, id udmrepo.ID) (udmrepo.Snapshot, error) {
|
|
ret := _mock.Called(ctx, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSnapshot")
|
|
}
|
|
|
|
var r0 udmrepo.Snapshot
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) (udmrepo.Snapshot, error)); ok {
|
|
return returnFunc(ctx, id)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) udmrepo.Snapshot); ok {
|
|
r0 = returnFunc(ctx, id)
|
|
} else {
|
|
r0 = ret.Get(0).(udmrepo.Snapshot)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.ID) error); ok {
|
|
r1 = returnFunc(ctx, id)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// BackupRepo_GetSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSnapshot'
|
|
type BackupRepo_GetSnapshot_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSnapshot is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - id udmrepo.ID
|
|
func (_e *BackupRepo_Expecter) GetSnapshot(ctx interface{}, id interface{}) *BackupRepo_GetSnapshot_Call {
|
|
return &BackupRepo_GetSnapshot_Call{Call: _e.mock.On("GetSnapshot", ctx, id)}
|
|
}
|
|
|
|
func (_c *BackupRepo_GetSnapshot_Call) Run(run func(ctx context.Context, id udmrepo.ID)) *BackupRepo_GetSnapshot_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 udmrepo.ID
|
|
if args[1] != nil {
|
|
arg1 = args[1].(udmrepo.ID)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_GetSnapshot_Call) Return(snapshot udmrepo.Snapshot, err error) *BackupRepo_GetSnapshot_Call {
|
|
_c.Call.Return(snapshot, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_GetSnapshot_Call) RunAndReturn(run func(ctx context.Context, id udmrepo.ID) (udmrepo.Snapshot, error)) *BackupRepo_GetSnapshot_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListSnapshot provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) ListSnapshot(ctx context.Context, source string) ([]udmrepo.Snapshot, error) {
|
|
ret := _mock.Called(ctx, source)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListSnapshot")
|
|
}
|
|
|
|
var r0 []udmrepo.Snapshot
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) ([]udmrepo.Snapshot, error)); ok {
|
|
return returnFunc(ctx, source)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, string) []udmrepo.Snapshot); ok {
|
|
r0 = returnFunc(ctx, source)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]udmrepo.Snapshot)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = returnFunc(ctx, source)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// BackupRepo_ListSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListSnapshot'
|
|
type BackupRepo_ListSnapshot_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListSnapshot is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - source string
|
|
func (_e *BackupRepo_Expecter) ListSnapshot(ctx interface{}, source interface{}) *BackupRepo_ListSnapshot_Call {
|
|
return &BackupRepo_ListSnapshot_Call{Call: _e.mock.On("ListSnapshot", ctx, source)}
|
|
}
|
|
|
|
func (_c *BackupRepo_ListSnapshot_Call) Run(run func(ctx context.Context, source string)) *BackupRepo_ListSnapshot_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 string
|
|
if args[1] != nil {
|
|
arg1 = args[1].(string)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_ListSnapshot_Call) Return(snapshots []udmrepo.Snapshot, err error) *BackupRepo_ListSnapshot_Call {
|
|
_c.Call.Return(snapshots, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_ListSnapshot_Call) RunAndReturn(run func(ctx context.Context, source string) ([]udmrepo.Snapshot, error)) *BackupRepo_ListSnapshot_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewObjectWriter provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) NewObjectWriter(ctx context.Context, opt udmrepo.ObjectWriteOptions) (udmrepo.ObjectWriter, error) {
|
|
ret := _mock.Called(ctx, opt)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for NewObjectWriter")
|
|
}
|
|
|
|
var r0 udmrepo.ObjectWriter
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ObjectWriteOptions) (udmrepo.ObjectWriter, error)); ok {
|
|
return returnFunc(ctx, opt)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ObjectWriteOptions) udmrepo.ObjectWriter); ok {
|
|
r0 = returnFunc(ctx, opt)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(udmrepo.ObjectWriter)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.ObjectWriteOptions) error); ok {
|
|
r1 = returnFunc(ctx, opt)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// BackupRepo_NewObjectWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewObjectWriter'
|
|
type BackupRepo_NewObjectWriter_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// NewObjectWriter is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - opt udmrepo.ObjectWriteOptions
|
|
func (_e *BackupRepo_Expecter) NewObjectWriter(ctx interface{}, opt interface{}) *BackupRepo_NewObjectWriter_Call {
|
|
return &BackupRepo_NewObjectWriter_Call{Call: _e.mock.On("NewObjectWriter", ctx, opt)}
|
|
}
|
|
|
|
func (_c *BackupRepo_NewObjectWriter_Call) Run(run func(ctx context.Context, opt udmrepo.ObjectWriteOptions)) *BackupRepo_NewObjectWriter_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 udmrepo.ObjectWriteOptions
|
|
if args[1] != nil {
|
|
arg1 = args[1].(udmrepo.ObjectWriteOptions)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_NewObjectWriter_Call) Return(objectWriter udmrepo.ObjectWriter, err error) *BackupRepo_NewObjectWriter_Call {
|
|
_c.Call.Return(objectWriter, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_NewObjectWriter_Call) RunAndReturn(run func(ctx context.Context, opt udmrepo.ObjectWriteOptions) (udmrepo.ObjectWriter, error)) *BackupRepo_NewObjectWriter_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// OpenObject provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) OpenObject(ctx context.Context, id udmrepo.ID) (udmrepo.ObjectReader, error) {
|
|
ret := _mock.Called(ctx, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for OpenObject")
|
|
}
|
|
|
|
var r0 udmrepo.ObjectReader
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) (udmrepo.ObjectReader, error)); ok {
|
|
return returnFunc(ctx, id)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) udmrepo.ObjectReader); ok {
|
|
r0 = returnFunc(ctx, id)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(udmrepo.ObjectReader)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.ID) error); ok {
|
|
r1 = returnFunc(ctx, id)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// BackupRepo_OpenObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenObject'
|
|
type BackupRepo_OpenObject_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// OpenObject is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - id udmrepo.ID
|
|
func (_e *BackupRepo_Expecter) OpenObject(ctx interface{}, id interface{}) *BackupRepo_OpenObject_Call {
|
|
return &BackupRepo_OpenObject_Call{Call: _e.mock.On("OpenObject", ctx, id)}
|
|
}
|
|
|
|
func (_c *BackupRepo_OpenObject_Call) Run(run func(ctx context.Context, id udmrepo.ID)) *BackupRepo_OpenObject_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 udmrepo.ID
|
|
if args[1] != nil {
|
|
arg1 = args[1].(udmrepo.ID)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_OpenObject_Call) Return(objectReader udmrepo.ObjectReader, err error) *BackupRepo_OpenObject_Call {
|
|
_c.Call.Return(objectReader, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_OpenObject_Call) RunAndReturn(run func(ctx context.Context, id udmrepo.ID) (udmrepo.ObjectReader, error)) *BackupRepo_OpenObject_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// PutManifest provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) PutManifest(ctx context.Context, mani udmrepo.RepoManifest) (udmrepo.ID, error) {
|
|
ret := _mock.Called(ctx, mani)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PutManifest")
|
|
}
|
|
|
|
var r0 udmrepo.ID
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.RepoManifest) (udmrepo.ID, error)); ok {
|
|
return returnFunc(ctx, mani)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.RepoManifest) udmrepo.ID); ok {
|
|
r0 = returnFunc(ctx, mani)
|
|
} else {
|
|
r0 = ret.Get(0).(udmrepo.ID)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.RepoManifest) error); ok {
|
|
r1 = returnFunc(ctx, mani)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// BackupRepo_PutManifest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutManifest'
|
|
type BackupRepo_PutManifest_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// PutManifest is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - mani udmrepo.RepoManifest
|
|
func (_e *BackupRepo_Expecter) PutManifest(ctx interface{}, mani interface{}) *BackupRepo_PutManifest_Call {
|
|
return &BackupRepo_PutManifest_Call{Call: _e.mock.On("PutManifest", ctx, mani)}
|
|
}
|
|
|
|
func (_c *BackupRepo_PutManifest_Call) Run(run func(ctx context.Context, mani udmrepo.RepoManifest)) *BackupRepo_PutManifest_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 udmrepo.RepoManifest
|
|
if args[1] != nil {
|
|
arg1 = args[1].(udmrepo.RepoManifest)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_PutManifest_Call) Return(iD udmrepo.ID, err error) *BackupRepo_PutManifest_Call {
|
|
_c.Call.Return(iD, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_PutManifest_Call) RunAndReturn(run func(ctx context.Context, mani udmrepo.RepoManifest) (udmrepo.ID, error)) *BackupRepo_PutManifest_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ReadMetadata provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) ReadMetadata(ctx context.Context, id udmrepo.ID) (*udmrepo.Metadata, error) {
|
|
ret := _mock.Called(ctx, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ReadMetadata")
|
|
}
|
|
|
|
var r0 *udmrepo.Metadata
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) (*udmrepo.Metadata, error)); ok {
|
|
return returnFunc(ctx, id)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.ID) *udmrepo.Metadata); ok {
|
|
r0 = returnFunc(ctx, id)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*udmrepo.Metadata)
|
|
}
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.ID) error); ok {
|
|
r1 = returnFunc(ctx, id)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// BackupRepo_ReadMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadMetadata'
|
|
type BackupRepo_ReadMetadata_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ReadMetadata is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - id udmrepo.ID
|
|
func (_e *BackupRepo_Expecter) ReadMetadata(ctx interface{}, id interface{}) *BackupRepo_ReadMetadata_Call {
|
|
return &BackupRepo_ReadMetadata_Call{Call: _e.mock.On("ReadMetadata", ctx, id)}
|
|
}
|
|
|
|
func (_c *BackupRepo_ReadMetadata_Call) Run(run func(ctx context.Context, id udmrepo.ID)) *BackupRepo_ReadMetadata_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 udmrepo.ID
|
|
if args[1] != nil {
|
|
arg1 = args[1].(udmrepo.ID)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_ReadMetadata_Call) Return(metadata *udmrepo.Metadata, err error) *BackupRepo_ReadMetadata_Call {
|
|
_c.Call.Return(metadata, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_ReadMetadata_Call) RunAndReturn(run func(ctx context.Context, id udmrepo.ID) (*udmrepo.Metadata, error)) *BackupRepo_ReadMetadata_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SaveSnapshot provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) SaveSnapshot(ctx context.Context, snapshot udmrepo.Snapshot) (udmrepo.ID, error) {
|
|
ret := _mock.Called(ctx, snapshot)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SaveSnapshot")
|
|
}
|
|
|
|
var r0 udmrepo.ID
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.Snapshot) (udmrepo.ID, error)); ok {
|
|
return returnFunc(ctx, snapshot)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, udmrepo.Snapshot) udmrepo.ID); ok {
|
|
r0 = returnFunc(ctx, snapshot)
|
|
} else {
|
|
r0 = ret.Get(0).(udmrepo.ID)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, udmrepo.Snapshot) error); ok {
|
|
r1 = returnFunc(ctx, snapshot)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// BackupRepo_SaveSnapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SaveSnapshot'
|
|
type BackupRepo_SaveSnapshot_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SaveSnapshot is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - snapshot udmrepo.Snapshot
|
|
func (_e *BackupRepo_Expecter) SaveSnapshot(ctx interface{}, snapshot interface{}) *BackupRepo_SaveSnapshot_Call {
|
|
return &BackupRepo_SaveSnapshot_Call{Call: _e.mock.On("SaveSnapshot", ctx, snapshot)}
|
|
}
|
|
|
|
func (_c *BackupRepo_SaveSnapshot_Call) Run(run func(ctx context.Context, snapshot udmrepo.Snapshot)) *BackupRepo_SaveSnapshot_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 udmrepo.Snapshot
|
|
if args[1] != nil {
|
|
arg1 = args[1].(udmrepo.Snapshot)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_SaveSnapshot_Call) Return(iD udmrepo.ID, err error) *BackupRepo_SaveSnapshot_Call {
|
|
_c.Call.Return(iD, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_SaveSnapshot_Call) RunAndReturn(run func(ctx context.Context, snapshot udmrepo.Snapshot) (udmrepo.ID, error)) *BackupRepo_SaveSnapshot_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Time provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) Time() time.Time {
|
|
ret := _mock.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Time")
|
|
}
|
|
|
|
var r0 time.Time
|
|
if returnFunc, ok := ret.Get(0).(func() time.Time); ok {
|
|
r0 = returnFunc()
|
|
} else {
|
|
r0 = ret.Get(0).(time.Time)
|
|
}
|
|
return r0
|
|
}
|
|
|
|
// BackupRepo_Time_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Time'
|
|
type BackupRepo_Time_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Time is a helper method to define mock.On call
|
|
func (_e *BackupRepo_Expecter) Time() *BackupRepo_Time_Call {
|
|
return &BackupRepo_Time_Call{Call: _e.mock.On("Time")}
|
|
}
|
|
|
|
func (_c *BackupRepo_Time_Call) Run(run func()) *BackupRepo_Time_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_Time_Call) Return(time1 time.Time) *BackupRepo_Time_Call {
|
|
_c.Call.Return(time1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_Time_Call) RunAndReturn(run func() time.Time) *BackupRepo_Time_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// WriteMetadata provides a mock function for the type BackupRepo
|
|
func (_mock *BackupRepo) WriteMetadata(ctx context.Context, meta *udmrepo.Metadata, opt udmrepo.ObjectWriteOptions) (udmrepo.ID, error) {
|
|
ret := _mock.Called(ctx, meta, opt)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for WriteMetadata")
|
|
}
|
|
|
|
var r0 udmrepo.ID
|
|
var r1 error
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *udmrepo.Metadata, udmrepo.ObjectWriteOptions) (udmrepo.ID, error)); ok {
|
|
return returnFunc(ctx, meta, opt)
|
|
}
|
|
if returnFunc, ok := ret.Get(0).(func(context.Context, *udmrepo.Metadata, udmrepo.ObjectWriteOptions) udmrepo.ID); ok {
|
|
r0 = returnFunc(ctx, meta, opt)
|
|
} else {
|
|
r0 = ret.Get(0).(udmrepo.ID)
|
|
}
|
|
if returnFunc, ok := ret.Get(1).(func(context.Context, *udmrepo.Metadata, udmrepo.ObjectWriteOptions) error); ok {
|
|
r1 = returnFunc(ctx, meta, opt)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
return r0, r1
|
|
}
|
|
|
|
// BackupRepo_WriteMetadata_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteMetadata'
|
|
type BackupRepo_WriteMetadata_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// WriteMetadata is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - meta *udmrepo.Metadata
|
|
// - opt udmrepo.ObjectWriteOptions
|
|
func (_e *BackupRepo_Expecter) WriteMetadata(ctx interface{}, meta interface{}, opt interface{}) *BackupRepo_WriteMetadata_Call {
|
|
return &BackupRepo_WriteMetadata_Call{Call: _e.mock.On("WriteMetadata", ctx, meta, opt)}
|
|
}
|
|
|
|
func (_c *BackupRepo_WriteMetadata_Call) Run(run func(ctx context.Context, meta *udmrepo.Metadata, opt udmrepo.ObjectWriteOptions)) *BackupRepo_WriteMetadata_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
var arg0 context.Context
|
|
if args[0] != nil {
|
|
arg0 = args[0].(context.Context)
|
|
}
|
|
var arg1 *udmrepo.Metadata
|
|
if args[1] != nil {
|
|
arg1 = args[1].(*udmrepo.Metadata)
|
|
}
|
|
var arg2 udmrepo.ObjectWriteOptions
|
|
if args[2] != nil {
|
|
arg2 = args[2].(udmrepo.ObjectWriteOptions)
|
|
}
|
|
run(
|
|
arg0,
|
|
arg1,
|
|
arg2,
|
|
)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_WriteMetadata_Call) Return(iD udmrepo.ID, err error) *BackupRepo_WriteMetadata_Call {
|
|
_c.Call.Return(iD, err)
|
|
return _c
|
|
}
|
|
|
|
func (_c *BackupRepo_WriteMetadata_Call) RunAndReturn(run func(ctx context.Context, meta *udmrepo.Metadata, opt udmrepo.ObjectWriteOptions) (udmrepo.ID, error)) *BackupRepo_WriteMetadata_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|