github.com/cs3org/reva/v2@v2.27.7/pkg/share/mocks/Manager.go

// Copyright 2018-2022 CERN
//
// 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.
//
// In applying this license, CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.

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

package mocks

import (
	context "context"

	collaborationv1beta1 "github.com/cs3org/go-cs3apis/cs3/sharing/collaboration/v1beta1"

	fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb"

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

	providerv1beta1 "github.com/cs3org/go-cs3apis/cs3/storage/provider/v1beta1"

	userv1beta1 "github.com/cs3org/go-cs3apis/cs3/identity/user/v1beta1"
)

// Manager is an autogenerated mock type for the Manager type
type Manager struct {
	mock.Mock
}

type Manager_Expecter struct {
	mock *mock.Mock
}

func (_m *Manager) EXPECT() *Manager_Expecter {
	return &Manager_Expecter{mock: &_m.Mock}
}

// GetReceivedShare provides a mock function with given fields: ctx, ref
func (_m *Manager) GetReceivedShare(ctx context.Context, ref *collaborationv1beta1.ShareReference) (*collaborationv1beta1.ReceivedShare, error) {
	ret := _m.Called(ctx, ref)

	if len(ret) == 0 {
		panic("no return value specified for GetReceivedShare")
	}

	var r0 *collaborationv1beta1.ReceivedShare
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ShareReference) (*collaborationv1beta1.ReceivedShare, error)); ok {
		return rf(ctx, ref)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ShareReference) *collaborationv1beta1.ReceivedShare); ok {
		r0 = rf(ctx, ref)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*collaborationv1beta1.ReceivedShare)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.ShareReference) error); ok {
		r1 = rf(ctx, ref)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Manager_GetReceivedShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReceivedShare'
type Manager_GetReceivedShare_Call struct {
	*mock.Call
}

// GetReceivedShare is a helper method to define mock.On call
//   - ctx context.Context
//   - ref *collaborationv1beta1.ShareReference
func (_e *Manager_Expecter) GetReceivedShare(ctx interface{}, ref interface{}) *Manager_GetReceivedShare_Call {
	return &Manager_GetReceivedShare_Call{Call: _e.mock.On("GetReceivedShare", ctx, ref)}
}

func (_c *Manager_GetReceivedShare_Call) Run(run func(ctx context.Context, ref *collaborationv1beta1.ShareReference)) *Manager_GetReceivedShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.ShareReference))
	})
	return _c
}

func (_c *Manager_GetReceivedShare_Call) Return(_a0 *collaborationv1beta1.ReceivedShare, _a1 error) *Manager_GetReceivedShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Manager_GetReceivedShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.ShareReference) (*collaborationv1beta1.ReceivedShare, error)) *Manager_GetReceivedShare_Call {
	_c.Call.Return(run)
	return _c
}

// GetShare provides a mock function with given fields: ctx, ref
func (_m *Manager) GetShare(ctx context.Context, ref *collaborationv1beta1.ShareReference) (*collaborationv1beta1.Share, error) {
	ret := _m.Called(ctx, ref)

	if len(ret) == 0 {
		panic("no return value specified for GetShare")
	}

	var r0 *collaborationv1beta1.Share
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ShareReference) (*collaborationv1beta1.Share, error)); ok {
		return rf(ctx, ref)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ShareReference) *collaborationv1beta1.Share); ok {
		r0 = rf(ctx, ref)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*collaborationv1beta1.Share)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.ShareReference) error); ok {
		r1 = rf(ctx, ref)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Manager_GetShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShare'
type Manager_GetShare_Call struct {
	*mock.Call
}

// GetShare is a helper method to define mock.On call
//   - ctx context.Context
//   - ref *collaborationv1beta1.ShareReference
func (_e *Manager_Expecter) GetShare(ctx interface{}, ref interface{}) *Manager_GetShare_Call {
	return &Manager_GetShare_Call{Call: _e.mock.On("GetShare", ctx, ref)}
}

func (_c *Manager_GetShare_Call) Run(run func(ctx context.Context, ref *collaborationv1beta1.ShareReference)) *Manager_GetShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.ShareReference))
	})
	return _c
}

func (_c *Manager_GetShare_Call) Return(_a0 *collaborationv1beta1.Share, _a1 error) *Manager_GetShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Manager_GetShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.ShareReference) (*collaborationv1beta1.Share, error)) *Manager_GetShare_Call {
	_c.Call.Return(run)
	return _c
}

// ListReceivedShares provides a mock function with given fields: ctx, filters, forUser
func (_m *Manager) ListReceivedShares(ctx context.Context, filters []*collaborationv1beta1.Filter, forUser *userv1beta1.UserId) ([]*collaborationv1beta1.ReceivedShare, error) {
	ret := _m.Called(ctx, filters, forUser)

	if len(ret) == 0 {
		panic("no return value specified for ListReceivedShares")
	}

	var r0 []*collaborationv1beta1.ReceivedShare
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []*collaborationv1beta1.Filter, *userv1beta1.UserId) ([]*collaborationv1beta1.ReceivedShare, error)); ok {
		return rf(ctx, filters, forUser)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []*collaborationv1beta1.Filter, *userv1beta1.UserId) []*collaborationv1beta1.ReceivedShare); ok {
		r0 = rf(ctx, filters, forUser)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*collaborationv1beta1.ReceivedShare)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []*collaborationv1beta1.Filter, *userv1beta1.UserId) error); ok {
		r1 = rf(ctx, filters, forUser)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Manager_ListReceivedShares_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListReceivedShares'
type Manager_ListReceivedShares_Call struct {
	*mock.Call
}

// ListReceivedShares is a helper method to define mock.On call
//   - ctx context.Context
//   - filters []*collaborationv1beta1.Filter
//   - forUser *userv1beta1.UserId
func (_e *Manager_Expecter) ListReceivedShares(ctx interface{}, filters interface{}, forUser interface{}) *Manager_ListReceivedShares_Call {
	return &Manager_ListReceivedShares_Call{Call: _e.mock.On("ListReceivedShares", ctx, filters, forUser)}
}

func (_c *Manager_ListReceivedShares_Call) Run(run func(ctx context.Context, filters []*collaborationv1beta1.Filter, forUser *userv1beta1.UserId)) *Manager_ListReceivedShares_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]*collaborationv1beta1.Filter), args[2].(*userv1beta1.UserId))
	})
	return _c
}

func (_c *Manager_ListReceivedShares_Call) Return(_a0 []*collaborationv1beta1.ReceivedShare, _a1 error) *Manager_ListReceivedShares_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Manager_ListReceivedShares_Call) RunAndReturn(run func(context.Context, []*collaborationv1beta1.Filter, *userv1beta1.UserId) ([]*collaborationv1beta1.ReceivedShare, error)) *Manager_ListReceivedShares_Call {
	_c.Call.Return(run)
	return _c
}

// ListShares provides a mock function with given fields: ctx, filters
func (_m *Manager) ListShares(ctx context.Context, filters []*collaborationv1beta1.Filter) ([]*collaborationv1beta1.Share, error) {
	ret := _m.Called(ctx, filters)

	if len(ret) == 0 {
		panic("no return value specified for ListShares")
	}

	var r0 []*collaborationv1beta1.Share
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, []*collaborationv1beta1.Filter) ([]*collaborationv1beta1.Share, error)); ok {
		return rf(ctx, filters)
	}
	if rf, ok := ret.Get(0).(func(context.Context, []*collaborationv1beta1.Filter) []*collaborationv1beta1.Share); ok {
		r0 = rf(ctx, filters)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*collaborationv1beta1.Share)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, []*collaborationv1beta1.Filter) error); ok {
		r1 = rf(ctx, filters)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Manager_ListShares_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListShares'
type Manager_ListShares_Call struct {
	*mock.Call
}

// ListShares is a helper method to define mock.On call
//   - ctx context.Context
//   - filters []*collaborationv1beta1.Filter
func (_e *Manager_Expecter) ListShares(ctx interface{}, filters interface{}) *Manager_ListShares_Call {
	return &Manager_ListShares_Call{Call: _e.mock.On("ListShares", ctx, filters)}
}

func (_c *Manager_ListShares_Call) Run(run func(ctx context.Context, filters []*collaborationv1beta1.Filter)) *Manager_ListShares_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].([]*collaborationv1beta1.Filter))
	})
	return _c
}

func (_c *Manager_ListShares_Call) Return(_a0 []*collaborationv1beta1.Share, _a1 error) *Manager_ListShares_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Manager_ListShares_Call) RunAndReturn(run func(context.Context, []*collaborationv1beta1.Filter) ([]*collaborationv1beta1.Share, error)) *Manager_ListShares_Call {
	_c.Call.Return(run)
	return _c
}

// Share provides a mock function with given fields: ctx, md, g
func (_m *Manager) Share(ctx context.Context, md *providerv1beta1.ResourceInfo, g *collaborationv1beta1.ShareGrant) (*collaborationv1beta1.Share, error) {
	ret := _m.Called(ctx, md, g)

	if len(ret) == 0 {
		panic("no return value specified for Share")
	}

	var r0 *collaborationv1beta1.Share
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ResourceInfo, *collaborationv1beta1.ShareGrant) (*collaborationv1beta1.Share, error)); ok {
		return rf(ctx, md, g)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *providerv1beta1.ResourceInfo, *collaborationv1beta1.ShareGrant) *collaborationv1beta1.Share); ok {
		r0 = rf(ctx, md, g)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*collaborationv1beta1.Share)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *providerv1beta1.ResourceInfo, *collaborationv1beta1.ShareGrant) error); ok {
		r1 = rf(ctx, md, g)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Manager_Share_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Share'
type Manager_Share_Call struct {
	*mock.Call
}

// Share is a helper method to define mock.On call
//   - ctx context.Context
//   - md *providerv1beta1.ResourceInfo
//   - g *collaborationv1beta1.ShareGrant
func (_e *Manager_Expecter) Share(ctx interface{}, md interface{}, g interface{}) *Manager_Share_Call {
	return &Manager_Share_Call{Call: _e.mock.On("Share", ctx, md, g)}
}

func (_c *Manager_Share_Call) Run(run func(ctx context.Context, md *providerv1beta1.ResourceInfo, g *collaborationv1beta1.ShareGrant)) *Manager_Share_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*providerv1beta1.ResourceInfo), args[2].(*collaborationv1beta1.ShareGrant))
	})
	return _c
}

func (_c *Manager_Share_Call) Return(_a0 *collaborationv1beta1.Share, _a1 error) *Manager_Share_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Manager_Share_Call) RunAndReturn(run func(context.Context, *providerv1beta1.ResourceInfo, *collaborationv1beta1.ShareGrant) (*collaborationv1beta1.Share, error)) *Manager_Share_Call {
	_c.Call.Return(run)
	return _c
}

// Unshare provides a mock function with given fields: ctx, ref
func (_m *Manager) Unshare(ctx context.Context, ref *collaborationv1beta1.ShareReference) error {
	ret := _m.Called(ctx, ref)

	if len(ret) == 0 {
		panic("no return value specified for Unshare")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ShareReference) error); ok {
		r0 = rf(ctx, ref)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// Manager_Unshare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unshare'
type Manager_Unshare_Call struct {
	*mock.Call
}

// Unshare is a helper method to define mock.On call
//   - ctx context.Context
//   - ref *collaborationv1beta1.ShareReference
func (_e *Manager_Expecter) Unshare(ctx interface{}, ref interface{}) *Manager_Unshare_Call {
	return &Manager_Unshare_Call{Call: _e.mock.On("Unshare", ctx, ref)}
}

func (_c *Manager_Unshare_Call) Run(run func(ctx context.Context, ref *collaborationv1beta1.ShareReference)) *Manager_Unshare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.ShareReference))
	})
	return _c
}

func (_c *Manager_Unshare_Call) Return(_a0 error) *Manager_Unshare_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *Manager_Unshare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.ShareReference) error) *Manager_Unshare_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateReceivedShare provides a mock function with given fields: ctx, _a1, fieldMask, forUser
func (_m *Manager) UpdateReceivedShare(ctx context.Context, _a1 *collaborationv1beta1.ReceivedShare, fieldMask *fieldmaskpb.FieldMask, forUser *userv1beta1.UserId) (*collaborationv1beta1.ReceivedShare, error) {
	ret := _m.Called(ctx, _a1, fieldMask, forUser)

	if len(ret) == 0 {
		panic("no return value specified for UpdateReceivedShare")
	}

	var r0 *collaborationv1beta1.ReceivedShare
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ReceivedShare, *fieldmaskpb.FieldMask, *userv1beta1.UserId) (*collaborationv1beta1.ReceivedShare, error)); ok {
		return rf(ctx, _a1, fieldMask, forUser)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ReceivedShare, *fieldmaskpb.FieldMask, *userv1beta1.UserId) *collaborationv1beta1.ReceivedShare); ok {
		r0 = rf(ctx, _a1, fieldMask, forUser)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*collaborationv1beta1.ReceivedShare)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.ReceivedShare, *fieldmaskpb.FieldMask, *userv1beta1.UserId) error); ok {
		r1 = rf(ctx, _a1, fieldMask, forUser)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Manager_UpdateReceivedShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateReceivedShare'
type Manager_UpdateReceivedShare_Call struct {
	*mock.Call
}

// UpdateReceivedShare is a helper method to define mock.On call
//   - ctx context.Context
//   - _a1 *collaborationv1beta1.ReceivedShare
//   - fieldMask *fieldmaskpb.FieldMask
//   - forUser *userv1beta1.UserId
func (_e *Manager_Expecter) UpdateReceivedShare(ctx interface{}, _a1 interface{}, fieldMask interface{}, forUser interface{}) *Manager_UpdateReceivedShare_Call {
	return &Manager_UpdateReceivedShare_Call{Call: _e.mock.On("UpdateReceivedShare", ctx, _a1, fieldMask, forUser)}
}

func (_c *Manager_UpdateReceivedShare_Call) Run(run func(ctx context.Context, _a1 *collaborationv1beta1.ReceivedShare, fieldMask *fieldmaskpb.FieldMask, forUser *userv1beta1.UserId)) *Manager_UpdateReceivedShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.ReceivedShare), args[2].(*fieldmaskpb.FieldMask), args[3].(*userv1beta1.UserId))
	})
	return _c
}

func (_c *Manager_UpdateReceivedShare_Call) Return(_a0 *collaborationv1beta1.ReceivedShare, _a1 error) *Manager_UpdateReceivedShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Manager_UpdateReceivedShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.ReceivedShare, *fieldmaskpb.FieldMask, *userv1beta1.UserId) (*collaborationv1beta1.ReceivedShare, error)) *Manager_UpdateReceivedShare_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateShare provides a mock function with given fields: ctx, ref, p, updated, fieldMask
func (_m *Manager) UpdateShare(ctx context.Context, ref *collaborationv1beta1.ShareReference, p *collaborationv1beta1.SharePermissions, updated *collaborationv1beta1.Share, fieldMask *fieldmaskpb.FieldMask) (*collaborationv1beta1.Share, error) {
	ret := _m.Called(ctx, ref, p, updated, fieldMask)

	if len(ret) == 0 {
		panic("no return value specified for UpdateShare")
	}

	var r0 *collaborationv1beta1.Share
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ShareReference, *collaborationv1beta1.SharePermissions, *collaborationv1beta1.Share, *fieldmaskpb.FieldMask) (*collaborationv1beta1.Share, error)); ok {
		return rf(ctx, ref, p, updated, fieldMask)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *collaborationv1beta1.ShareReference, *collaborationv1beta1.SharePermissions, *collaborationv1beta1.Share, *fieldmaskpb.FieldMask) *collaborationv1beta1.Share); ok {
		r0 = rf(ctx, ref, p, updated, fieldMask)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*collaborationv1beta1.Share)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *collaborationv1beta1.ShareReference, *collaborationv1beta1.SharePermissions, *collaborationv1beta1.Share, *fieldmaskpb.FieldMask) error); ok {
		r1 = rf(ctx, ref, p, updated, fieldMask)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Manager_UpdateShare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateShare'
type Manager_UpdateShare_Call struct {
	*mock.Call
}

// UpdateShare is a helper method to define mock.On call
//   - ctx context.Context
//   - ref *collaborationv1beta1.ShareReference
//   - p *collaborationv1beta1.SharePermissions
//   - updated *collaborationv1beta1.Share
//   - fieldMask *fieldmaskpb.FieldMask
func (_e *Manager_Expecter) UpdateShare(ctx interface{}, ref interface{}, p interface{}, updated interface{}, fieldMask interface{}) *Manager_UpdateShare_Call {
	return &Manager_UpdateShare_Call{Call: _e.mock.On("UpdateShare", ctx, ref, p, updated, fieldMask)}
}

func (_c *Manager_UpdateShare_Call) Run(run func(ctx context.Context, ref *collaborationv1beta1.ShareReference, p *collaborationv1beta1.SharePermissions, updated *collaborationv1beta1.Share, fieldMask *fieldmaskpb.FieldMask)) *Manager_UpdateShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*collaborationv1beta1.ShareReference), args[2].(*collaborationv1beta1.SharePermissions), args[3].(*collaborationv1beta1.Share), args[4].(*fieldmaskpb.FieldMask))
	})
	return _c
}

func (_c *Manager_UpdateShare_Call) Return(_a0 *collaborationv1beta1.Share, _a1 error) *Manager_UpdateShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Manager_UpdateShare_Call) RunAndReturn(run func(context.Context, *collaborationv1beta1.ShareReference, *collaborationv1beta1.SharePermissions, *collaborationv1beta1.Share, *fieldmaskpb.FieldMask) (*collaborationv1beta1.Share, error)) *Manager_UpdateShare_Call {
	_c.Call.Return(run)
	return _c
}

// NewManager creates a new instance of Manager. 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 NewManager(t interface {
	mock.TestingT
	Cleanup(func())
}) *Manager {
	mock := &Manager{}
	mock.Mock.Test(t)

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

	return mock
}