github.com/cs3org/reva/v2@v2.27.7/pkg/publicshare/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"

	linkv1beta1 "github.com/cs3org/go-cs3apis/cs3/sharing/link/v1beta1"
	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}
}

// CreatePublicShare provides a mock function with given fields: ctx, u, md, g
func (_m *Manager) CreatePublicShare(ctx context.Context, u *userv1beta1.User, md *providerv1beta1.ResourceInfo, g *linkv1beta1.Grant) (*linkv1beta1.PublicShare, error) {
	ret := _m.Called(ctx, u, md, g)

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

	var r0 *linkv1beta1.PublicShare
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.User, *providerv1beta1.ResourceInfo, *linkv1beta1.Grant) (*linkv1beta1.PublicShare, error)); ok {
		return rf(ctx, u, md, g)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.User, *providerv1beta1.ResourceInfo, *linkv1beta1.Grant) *linkv1beta1.PublicShare); ok {
		r0 = rf(ctx, u, md, g)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*linkv1beta1.PublicShare)
		}
	}

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

	return r0, r1
}

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

// CreatePublicShare is a helper method to define mock.On call
//   - ctx context.Context
//   - u *userv1beta1.User
//   - md *providerv1beta1.ResourceInfo
//   - g *linkv1beta1.Grant
func (_e *Manager_Expecter) CreatePublicShare(ctx interface{}, u interface{}, md interface{}, g interface{}) *Manager_CreatePublicShare_Call {
	return &Manager_CreatePublicShare_Call{Call: _e.mock.On("CreatePublicShare", ctx, u, md, g)}
}

func (_c *Manager_CreatePublicShare_Call) Run(run func(ctx context.Context, u *userv1beta1.User, md *providerv1beta1.ResourceInfo, g *linkv1beta1.Grant)) *Manager_CreatePublicShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*userv1beta1.User), args[2].(*providerv1beta1.ResourceInfo), args[3].(*linkv1beta1.Grant))
	})
	return _c
}

func (_c *Manager_CreatePublicShare_Call) Return(_a0 *linkv1beta1.PublicShare, _a1 error) *Manager_CreatePublicShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Manager_CreatePublicShare_Call) RunAndReturn(run func(context.Context, *userv1beta1.User, *providerv1beta1.ResourceInfo, *linkv1beta1.Grant) (*linkv1beta1.PublicShare, error)) *Manager_CreatePublicShare_Call {
	_c.Call.Return(run)
	return _c
}

// GetPublicShare provides a mock function with given fields: ctx, u, ref, sign
func (_m *Manager) GetPublicShare(ctx context.Context, u *userv1beta1.User, ref *linkv1beta1.PublicShareReference, sign bool) (*linkv1beta1.PublicShare, error) {
	ret := _m.Called(ctx, u, ref, sign)

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

	var r0 *linkv1beta1.PublicShare
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.User, *linkv1beta1.PublicShareReference, bool) (*linkv1beta1.PublicShare, error)); ok {
		return rf(ctx, u, ref, sign)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.User, *linkv1beta1.PublicShareReference, bool) *linkv1beta1.PublicShare); ok {
		r0 = rf(ctx, u, ref, sign)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*linkv1beta1.PublicShare)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *userv1beta1.User, *linkv1beta1.PublicShareReference, bool) error); ok {
		r1 = rf(ctx, u, ref, sign)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPublicShare is a helper method to define mock.On call
//   - ctx context.Context
//   - u *userv1beta1.User
//   - ref *linkv1beta1.PublicShareReference
//   - sign bool
func (_e *Manager_Expecter) GetPublicShare(ctx interface{}, u interface{}, ref interface{}, sign interface{}) *Manager_GetPublicShare_Call {
	return &Manager_GetPublicShare_Call{Call: _e.mock.On("GetPublicShare", ctx, u, ref, sign)}
}

func (_c *Manager_GetPublicShare_Call) Run(run func(ctx context.Context, u *userv1beta1.User, ref *linkv1beta1.PublicShareReference, sign bool)) *Manager_GetPublicShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*userv1beta1.User), args[2].(*linkv1beta1.PublicShareReference), args[3].(bool))
	})
	return _c
}

func (_c *Manager_GetPublicShare_Call) Return(_a0 *linkv1beta1.PublicShare, _a1 error) *Manager_GetPublicShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Manager_GetPublicShare_Call) RunAndReturn(run func(context.Context, *userv1beta1.User, *linkv1beta1.PublicShareReference, bool) (*linkv1beta1.PublicShare, error)) *Manager_GetPublicShare_Call {
	_c.Call.Return(run)
	return _c
}

// GetPublicShareByToken provides a mock function with given fields: ctx, token, auth, sign
func (_m *Manager) GetPublicShareByToken(ctx context.Context, token string, auth *linkv1beta1.PublicShareAuthentication, sign bool) (*linkv1beta1.PublicShare, error) {
	ret := _m.Called(ctx, token, auth, sign)

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

	var r0 *linkv1beta1.PublicShare
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *linkv1beta1.PublicShareAuthentication, bool) (*linkv1beta1.PublicShare, error)); ok {
		return rf(ctx, token, auth, sign)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, *linkv1beta1.PublicShareAuthentication, bool) *linkv1beta1.PublicShare); ok {
		r0 = rf(ctx, token, auth, sign)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*linkv1beta1.PublicShare)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, *linkv1beta1.PublicShareAuthentication, bool) error); ok {
		r1 = rf(ctx, token, auth, sign)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetPublicShareByToken is a helper method to define mock.On call
//   - ctx context.Context
//   - token string
//   - auth *linkv1beta1.PublicShareAuthentication
//   - sign bool
func (_e *Manager_Expecter) GetPublicShareByToken(ctx interface{}, token interface{}, auth interface{}, sign interface{}) *Manager_GetPublicShareByToken_Call {
	return &Manager_GetPublicShareByToken_Call{Call: _e.mock.On("GetPublicShareByToken", ctx, token, auth, sign)}
}

func (_c *Manager_GetPublicShareByToken_Call) Run(run func(ctx context.Context, token string, auth *linkv1beta1.PublicShareAuthentication, sign bool)) *Manager_GetPublicShareByToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*linkv1beta1.PublicShareAuthentication), args[3].(bool))
	})
	return _c
}

func (_c *Manager_GetPublicShareByToken_Call) Return(_a0 *linkv1beta1.PublicShare, _a1 error) *Manager_GetPublicShareByToken_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Manager_GetPublicShareByToken_Call) RunAndReturn(run func(context.Context, string, *linkv1beta1.PublicShareAuthentication, bool) (*linkv1beta1.PublicShare, error)) *Manager_GetPublicShareByToken_Call {
	_c.Call.Return(run)
	return _c
}

// ListPublicShares provides a mock function with given fields: ctx, u, filters, sign
func (_m *Manager) ListPublicShares(ctx context.Context, u *userv1beta1.User, filters []*linkv1beta1.ListPublicSharesRequest_Filter, sign bool) ([]*linkv1beta1.PublicShare, error) {
	ret := _m.Called(ctx, u, filters, sign)

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

	var r0 []*linkv1beta1.PublicShare
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.User, []*linkv1beta1.ListPublicSharesRequest_Filter, bool) ([]*linkv1beta1.PublicShare, error)); ok {
		return rf(ctx, u, filters, sign)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.User, []*linkv1beta1.ListPublicSharesRequest_Filter, bool) []*linkv1beta1.PublicShare); ok {
		r0 = rf(ctx, u, filters, sign)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*linkv1beta1.PublicShare)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *userv1beta1.User, []*linkv1beta1.ListPublicSharesRequest_Filter, bool) error); ok {
		r1 = rf(ctx, u, filters, sign)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ListPublicShares is a helper method to define mock.On call
//   - ctx context.Context
//   - u *userv1beta1.User
//   - filters []*linkv1beta1.ListPublicSharesRequest_Filter
//   - sign bool
func (_e *Manager_Expecter) ListPublicShares(ctx interface{}, u interface{}, filters interface{}, sign interface{}) *Manager_ListPublicShares_Call {
	return &Manager_ListPublicShares_Call{Call: _e.mock.On("ListPublicShares", ctx, u, filters, sign)}
}

func (_c *Manager_ListPublicShares_Call) Run(run func(ctx context.Context, u *userv1beta1.User, filters []*linkv1beta1.ListPublicSharesRequest_Filter, sign bool)) *Manager_ListPublicShares_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*userv1beta1.User), args[2].([]*linkv1beta1.ListPublicSharesRequest_Filter), args[3].(bool))
	})
	return _c
}

func (_c *Manager_ListPublicShares_Call) Return(_a0 []*linkv1beta1.PublicShare, _a1 error) *Manager_ListPublicShares_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Manager_ListPublicShares_Call) RunAndReturn(run func(context.Context, *userv1beta1.User, []*linkv1beta1.ListPublicSharesRequest_Filter, bool) ([]*linkv1beta1.PublicShare, error)) *Manager_ListPublicShares_Call {
	_c.Call.Return(run)
	return _c
}

// RevokePublicShare provides a mock function with given fields: ctx, u, ref
func (_m *Manager) RevokePublicShare(ctx context.Context, u *userv1beta1.User, ref *linkv1beta1.PublicShareReference) error {
	ret := _m.Called(ctx, u, ref)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.User, *linkv1beta1.PublicShareReference) error); ok {
		r0 = rf(ctx, u, ref)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RevokePublicShare is a helper method to define mock.On call
//   - ctx context.Context
//   - u *userv1beta1.User
//   - ref *linkv1beta1.PublicShareReference
func (_e *Manager_Expecter) RevokePublicShare(ctx interface{}, u interface{}, ref interface{}) *Manager_RevokePublicShare_Call {
	return &Manager_RevokePublicShare_Call{Call: _e.mock.On("RevokePublicShare", ctx, u, ref)}
}

func (_c *Manager_RevokePublicShare_Call) Run(run func(ctx context.Context, u *userv1beta1.User, ref *linkv1beta1.PublicShareReference)) *Manager_RevokePublicShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*userv1beta1.User), args[2].(*linkv1beta1.PublicShareReference))
	})
	return _c
}

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

func (_c *Manager_RevokePublicShare_Call) RunAndReturn(run func(context.Context, *userv1beta1.User, *linkv1beta1.PublicShareReference) error) *Manager_RevokePublicShare_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePublicShare provides a mock function with given fields: ctx, u, req
func (_m *Manager) UpdatePublicShare(ctx context.Context, u *userv1beta1.User, req *linkv1beta1.UpdatePublicShareRequest) (*linkv1beta1.PublicShare, error) {
	ret := _m.Called(ctx, u, req)

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

	var r0 *linkv1beta1.PublicShare
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.User, *linkv1beta1.UpdatePublicShareRequest) (*linkv1beta1.PublicShare, error)); ok {
		return rf(ctx, u, req)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *userv1beta1.User, *linkv1beta1.UpdatePublicShareRequest) *linkv1beta1.PublicShare); ok {
		r0 = rf(ctx, u, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*linkv1beta1.PublicShare)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *userv1beta1.User, *linkv1beta1.UpdatePublicShareRequest) error); ok {
		r1 = rf(ctx, u, req)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdatePublicShare is a helper method to define mock.On call
//   - ctx context.Context
//   - u *userv1beta1.User
//   - req *linkv1beta1.UpdatePublicShareRequest
func (_e *Manager_Expecter) UpdatePublicShare(ctx interface{}, u interface{}, req interface{}) *Manager_UpdatePublicShare_Call {
	return &Manager_UpdatePublicShare_Call{Call: _e.mock.On("UpdatePublicShare", ctx, u, req)}
}

func (_c *Manager_UpdatePublicShare_Call) Run(run func(ctx context.Context, u *userv1beta1.User, req *linkv1beta1.UpdatePublicShareRequest)) *Manager_UpdatePublicShare_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(*userv1beta1.User), args[2].(*linkv1beta1.UpdatePublicShareRequest))
	})
	return _c
}

func (_c *Manager_UpdatePublicShare_Call) Return(_a0 *linkv1beta1.PublicShare, _a1 error) *Manager_UpdatePublicShare_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *Manager_UpdatePublicShare_Call) RunAndReturn(run func(context.Context, *userv1beta1.User, *linkv1beta1.UpdatePublicShareRequest) (*linkv1beta1.PublicShare, error)) *Manager_UpdatePublicShare_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
}