owensmallwoodandSteve Simpson
a3daf0e39d
* initial generation * went through doc to add new resource * added dummy kind so grafana will run * added dummy handler and custom route * fix app name * gets custom route working - still a dummy route * adds groupOverride to manifest * adds quotas to grpc client and server * WIP - trying to get api recognized - not working * Gets route working * fixes group and resource vars * expects group and resource as separate params * set content-type header on response * removes Quotas kind and regens * Update grafana-app-sdk to v0.48.5 * Update codegen * updates manifest * formatting * updates grafana-app-sdk version to 0.48.5 * regen ResourceClient mocks * adds tests * remove commented code * uncomment go mod tidy * fix tests and make update workspace * adds quotas app to codeowners * formatting * make gen-apps * deletes temp file * fix generated folder code * make gofmt * make gen-go * make update-workspace * add COPY apps/quotas to Dockerfile * fix test mock * fixes undefined NewFolderStatus() * make gen-apps, and add func for NewFolderStatus * make gen-apps again * make update-workspace * regen folder_object_gen.go * gofmt * fix linting * apps/folder make update-workspace * make gen-apps * make gen-apps * fixes enterprise_imports.go * go get testcontainers * adds feature toggle * make update-workspace * fix go mod * fix another client mock --------- Co-authored-by: Steve Simpson <steve@grafana.com>
1224 lines
43 KiB
Go
1224 lines
43 KiB
Go
// Code generated by mockery v2.53.5. DO NOT EDIT.
|
|
|
|
package resource
|
|
|
|
import (
|
|
context "context"
|
|
|
|
grpc "google.golang.org/grpc"
|
|
|
|
mock "github.com/stretchr/testify/mock"
|
|
|
|
resourcepb "github.com/grafana/grafana/pkg/storage/unified/resourcepb"
|
|
)
|
|
|
|
// MockResourceClient is an autogenerated mock type for the ResourceClient type
|
|
type MockResourceClient struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockResourceClient_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockResourceClient) EXPECT() *MockResourceClient_Expecter {
|
|
return &MockResourceClient_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// BulkProcess provides a mock function with given fields: ctx, opts
|
|
func (_m *MockResourceClient) BulkProcess(ctx context.Context, opts ...grpc.CallOption) (resourcepb.BulkStore_BulkProcessClient, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for BulkProcess")
|
|
}
|
|
|
|
var r0 resourcepb.BulkStore_BulkProcessClient
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, ...grpc.CallOption) (resourcepb.BulkStore_BulkProcessClient, error)); ok {
|
|
return rf(ctx, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, ...grpc.CallOption) resourcepb.BulkStore_BulkProcessClient); ok {
|
|
r0 = rf(ctx, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(resourcepb.BulkStore_BulkProcessClient)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_BulkProcess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BulkProcess'
|
|
type MockResourceClient_BulkProcess_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// BulkProcess is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) BulkProcess(ctx interface{}, opts ...interface{}) *MockResourceClient_BulkProcess_Call {
|
|
return &MockResourceClient_BulkProcess_Call{Call: _e.mock.On("BulkProcess",
|
|
append([]interface{}{ctx}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_BulkProcess_Call) Run(run func(ctx context.Context, opts ...grpc.CallOption)) *MockResourceClient_BulkProcess_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-1)
|
|
for i, a := range args[1:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_BulkProcess_Call) Return(_a0 resourcepb.BulkStore_BulkProcessClient, _a1 error) *MockResourceClient_BulkProcess_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_BulkProcess_Call) RunAndReturn(run func(context.Context, ...grpc.CallOption) (resourcepb.BulkStore_BulkProcessClient, error)) *MockResourceClient_BulkProcess_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CountManagedObjects provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) CountManagedObjects(ctx context.Context, in *resourcepb.CountManagedObjectsRequest, opts ...grpc.CallOption) (*resourcepb.CountManagedObjectsResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CountManagedObjects")
|
|
}
|
|
|
|
var r0 *resourcepb.CountManagedObjectsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.CountManagedObjectsRequest, ...grpc.CallOption) (*resourcepb.CountManagedObjectsResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.CountManagedObjectsRequest, ...grpc.CallOption) *resourcepb.CountManagedObjectsResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.CountManagedObjectsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.CountManagedObjectsRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_CountManagedObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountManagedObjects'
|
|
type MockResourceClient_CountManagedObjects_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CountManagedObjects is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.CountManagedObjectsRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) CountManagedObjects(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_CountManagedObjects_Call {
|
|
return &MockResourceClient_CountManagedObjects_Call{Call: _e.mock.On("CountManagedObjects",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_CountManagedObjects_Call) Run(run func(ctx context.Context, in *resourcepb.CountManagedObjectsRequest, opts ...grpc.CallOption)) *MockResourceClient_CountManagedObjects_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.CountManagedObjectsRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_CountManagedObjects_Call) Return(_a0 *resourcepb.CountManagedObjectsResponse, _a1 error) *MockResourceClient_CountManagedObjects_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_CountManagedObjects_Call) RunAndReturn(run func(context.Context, *resourcepb.CountManagedObjectsRequest, ...grpc.CallOption) (*resourcepb.CountManagedObjectsResponse, error)) *MockResourceClient_CountManagedObjects_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Create provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) Create(ctx context.Context, in *resourcepb.CreateRequest, opts ...grpc.CallOption) (*resourcepb.CreateResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Create")
|
|
}
|
|
|
|
var r0 *resourcepb.CreateResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.CreateRequest, ...grpc.CallOption) (*resourcepb.CreateResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.CreateRequest, ...grpc.CallOption) *resourcepb.CreateResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.CreateResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.CreateRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
|
|
type MockResourceClient_Create_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Create is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.CreateRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) Create(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_Create_Call {
|
|
return &MockResourceClient_Create_Call{Call: _e.mock.On("Create",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_Create_Call) Run(run func(ctx context.Context, in *resourcepb.CreateRequest, opts ...grpc.CallOption)) *MockResourceClient_Create_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.CreateRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_Create_Call) Return(_a0 *resourcepb.CreateResponse, _a1 error) *MockResourceClient_Create_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_Create_Call) RunAndReturn(run func(context.Context, *resourcepb.CreateRequest, ...grpc.CallOption) (*resourcepb.CreateResponse, error)) *MockResourceClient_Create_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Delete provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) Delete(ctx context.Context, in *resourcepb.DeleteRequest, opts ...grpc.CallOption) (*resourcepb.DeleteResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Delete")
|
|
}
|
|
|
|
var r0 *resourcepb.DeleteResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.DeleteRequest, ...grpc.CallOption) (*resourcepb.DeleteResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.DeleteRequest, ...grpc.CallOption) *resourcepb.DeleteResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.DeleteResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.DeleteRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
|
|
type MockResourceClient_Delete_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Delete is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.DeleteRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) Delete(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_Delete_Call {
|
|
return &MockResourceClient_Delete_Call{Call: _e.mock.On("Delete",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_Delete_Call) Run(run func(ctx context.Context, in *resourcepb.DeleteRequest, opts ...grpc.CallOption)) *MockResourceClient_Delete_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.DeleteRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_Delete_Call) Return(_a0 *resourcepb.DeleteResponse, _a1 error) *MockResourceClient_Delete_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_Delete_Call) RunAndReturn(run func(context.Context, *resourcepb.DeleteRequest, ...grpc.CallOption) (*resourcepb.DeleteResponse, error)) *MockResourceClient_Delete_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetBlob provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) GetBlob(ctx context.Context, in *resourcepb.GetBlobRequest, opts ...grpc.CallOption) (*resourcepb.GetBlobResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetBlob")
|
|
}
|
|
|
|
var r0 *resourcepb.GetBlobResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.GetBlobRequest, ...grpc.CallOption) (*resourcepb.GetBlobResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.GetBlobRequest, ...grpc.CallOption) *resourcepb.GetBlobResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.GetBlobResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.GetBlobRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_GetBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlob'
|
|
type MockResourceClient_GetBlob_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetBlob is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.GetBlobRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) GetBlob(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_GetBlob_Call {
|
|
return &MockResourceClient_GetBlob_Call{Call: _e.mock.On("GetBlob",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_GetBlob_Call) Run(run func(ctx context.Context, in *resourcepb.GetBlobRequest, opts ...grpc.CallOption)) *MockResourceClient_GetBlob_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.GetBlobRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_GetBlob_Call) Return(_a0 *resourcepb.GetBlobResponse, _a1 error) *MockResourceClient_GetBlob_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_GetBlob_Call) RunAndReturn(run func(context.Context, *resourcepb.GetBlobRequest, ...grpc.CallOption) (*resourcepb.GetBlobResponse, error)) *MockResourceClient_GetBlob_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetQuotaUsage provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) GetQuotaUsage(ctx context.Context, in *resourcepb.QuotaUsageRequest, opts ...grpc.CallOption) (*resourcepb.QuotaUsageResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetQuotaUsage")
|
|
}
|
|
|
|
var r0 *resourcepb.QuotaUsageResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.QuotaUsageRequest, ...grpc.CallOption) (*resourcepb.QuotaUsageResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.QuotaUsageRequest, ...grpc.CallOption) *resourcepb.QuotaUsageResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.QuotaUsageResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.QuotaUsageRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_GetQuotaUsage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQuotaUsage'
|
|
type MockResourceClient_GetQuotaUsage_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetQuotaUsage is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.QuotaUsageRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) GetQuotaUsage(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_GetQuotaUsage_Call {
|
|
return &MockResourceClient_GetQuotaUsage_Call{Call: _e.mock.On("GetQuotaUsage",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_GetQuotaUsage_Call) Run(run func(ctx context.Context, in *resourcepb.QuotaUsageRequest, opts ...grpc.CallOption)) *MockResourceClient_GetQuotaUsage_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.QuotaUsageRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_GetQuotaUsage_Call) Return(_a0 *resourcepb.QuotaUsageResponse, _a1 error) *MockResourceClient_GetQuotaUsage_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_GetQuotaUsage_Call) RunAndReturn(run func(context.Context, *resourcepb.QuotaUsageRequest, ...grpc.CallOption) (*resourcepb.QuotaUsageResponse, error)) *MockResourceClient_GetQuotaUsage_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetStats provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) GetStats(ctx context.Context, in *resourcepb.ResourceStatsRequest, opts ...grpc.CallOption) (*resourcepb.ResourceStatsResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetStats")
|
|
}
|
|
|
|
var r0 *resourcepb.ResourceStatsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ResourceStatsRequest, ...grpc.CallOption) (*resourcepb.ResourceStatsResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ResourceStatsRequest, ...grpc.CallOption) *resourcepb.ResourceStatsResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.ResourceStatsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.ResourceStatsRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_GetStats_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStats'
|
|
type MockResourceClient_GetStats_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetStats is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.ResourceStatsRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) GetStats(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_GetStats_Call {
|
|
return &MockResourceClient_GetStats_Call{Call: _e.mock.On("GetStats",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_GetStats_Call) Run(run func(ctx context.Context, in *resourcepb.ResourceStatsRequest, opts ...grpc.CallOption)) *MockResourceClient_GetStats_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.ResourceStatsRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_GetStats_Call) Return(_a0 *resourcepb.ResourceStatsResponse, _a1 error) *MockResourceClient_GetStats_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_GetStats_Call) RunAndReturn(run func(context.Context, *resourcepb.ResourceStatsRequest, ...grpc.CallOption) (*resourcepb.ResourceStatsResponse, error)) *MockResourceClient_GetStats_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// IsHealthy provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) IsHealthy(ctx context.Context, in *resourcepb.HealthCheckRequest, opts ...grpc.CallOption) (*resourcepb.HealthCheckResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for IsHealthy")
|
|
}
|
|
|
|
var r0 *resourcepb.HealthCheckResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.HealthCheckRequest, ...grpc.CallOption) (*resourcepb.HealthCheckResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.HealthCheckRequest, ...grpc.CallOption) *resourcepb.HealthCheckResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.HealthCheckResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.HealthCheckRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_IsHealthy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsHealthy'
|
|
type MockResourceClient_IsHealthy_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// IsHealthy is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.HealthCheckRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) IsHealthy(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_IsHealthy_Call {
|
|
return &MockResourceClient_IsHealthy_Call{Call: _e.mock.On("IsHealthy",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_IsHealthy_Call) Run(run func(ctx context.Context, in *resourcepb.HealthCheckRequest, opts ...grpc.CallOption)) *MockResourceClient_IsHealthy_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.HealthCheckRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_IsHealthy_Call) Return(_a0 *resourcepb.HealthCheckResponse, _a1 error) *MockResourceClient_IsHealthy_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_IsHealthy_Call) RunAndReturn(run func(context.Context, *resourcepb.HealthCheckRequest, ...grpc.CallOption) (*resourcepb.HealthCheckResponse, error)) *MockResourceClient_IsHealthy_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// List provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) List(ctx context.Context, in *resourcepb.ListRequest, opts ...grpc.CallOption) (*resourcepb.ListResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for List")
|
|
}
|
|
|
|
var r0 *resourcepb.ListResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ListRequest, ...grpc.CallOption) (*resourcepb.ListResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ListRequest, ...grpc.CallOption) *resourcepb.ListResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.ListResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.ListRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'
|
|
type MockResourceClient_List_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// List is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.ListRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) List(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_List_Call {
|
|
return &MockResourceClient_List_Call{Call: _e.mock.On("List",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_List_Call) Run(run func(ctx context.Context, in *resourcepb.ListRequest, opts ...grpc.CallOption)) *MockResourceClient_List_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.ListRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_List_Call) Return(_a0 *resourcepb.ListResponse, _a1 error) *MockResourceClient_List_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_List_Call) RunAndReturn(run func(context.Context, *resourcepb.ListRequest, ...grpc.CallOption) (*resourcepb.ListResponse, error)) *MockResourceClient_List_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListManagedObjects provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) ListManagedObjects(ctx context.Context, in *resourcepb.ListManagedObjectsRequest, opts ...grpc.CallOption) (*resourcepb.ListManagedObjectsResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListManagedObjects")
|
|
}
|
|
|
|
var r0 *resourcepb.ListManagedObjectsResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ListManagedObjectsRequest, ...grpc.CallOption) (*resourcepb.ListManagedObjectsResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ListManagedObjectsRequest, ...grpc.CallOption) *resourcepb.ListManagedObjectsResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.ListManagedObjectsResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.ListManagedObjectsRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_ListManagedObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListManagedObjects'
|
|
type MockResourceClient_ListManagedObjects_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListManagedObjects is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.ListManagedObjectsRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) ListManagedObjects(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_ListManagedObjects_Call {
|
|
return &MockResourceClient_ListManagedObjects_Call{Call: _e.mock.On("ListManagedObjects",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_ListManagedObjects_Call) Run(run func(ctx context.Context, in *resourcepb.ListManagedObjectsRequest, opts ...grpc.CallOption)) *MockResourceClient_ListManagedObjects_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.ListManagedObjectsRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_ListManagedObjects_Call) Return(_a0 *resourcepb.ListManagedObjectsResponse, _a1 error) *MockResourceClient_ListManagedObjects_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_ListManagedObjects_Call) RunAndReturn(run func(context.Context, *resourcepb.ListManagedObjectsRequest, ...grpc.CallOption) (*resourcepb.ListManagedObjectsResponse, error)) *MockResourceClient_ListManagedObjects_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// PutBlob provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) PutBlob(ctx context.Context, in *resourcepb.PutBlobRequest, opts ...grpc.CallOption) (*resourcepb.PutBlobResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PutBlob")
|
|
}
|
|
|
|
var r0 *resourcepb.PutBlobResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.PutBlobRequest, ...grpc.CallOption) (*resourcepb.PutBlobResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.PutBlobRequest, ...grpc.CallOption) *resourcepb.PutBlobResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.PutBlobResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.PutBlobRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_PutBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBlob'
|
|
type MockResourceClient_PutBlob_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// PutBlob is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.PutBlobRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) PutBlob(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_PutBlob_Call {
|
|
return &MockResourceClient_PutBlob_Call{Call: _e.mock.On("PutBlob",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_PutBlob_Call) Run(run func(ctx context.Context, in *resourcepb.PutBlobRequest, opts ...grpc.CallOption)) *MockResourceClient_PutBlob_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.PutBlobRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_PutBlob_Call) Return(_a0 *resourcepb.PutBlobResponse, _a1 error) *MockResourceClient_PutBlob_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_PutBlob_Call) RunAndReturn(run func(context.Context, *resourcepb.PutBlobRequest, ...grpc.CallOption) (*resourcepb.PutBlobResponse, error)) *MockResourceClient_PutBlob_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Read provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) Read(ctx context.Context, in *resourcepb.ReadRequest, opts ...grpc.CallOption) (*resourcepb.ReadResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Read")
|
|
}
|
|
|
|
var r0 *resourcepb.ReadResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ReadRequest, ...grpc.CallOption) (*resourcepb.ReadResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ReadRequest, ...grpc.CallOption) *resourcepb.ReadResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.ReadResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.ReadRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'
|
|
type MockResourceClient_Read_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Read is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.ReadRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) Read(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_Read_Call {
|
|
return &MockResourceClient_Read_Call{Call: _e.mock.On("Read",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_Read_Call) Run(run func(ctx context.Context, in *resourcepb.ReadRequest, opts ...grpc.CallOption)) *MockResourceClient_Read_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.ReadRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_Read_Call) Return(_a0 *resourcepb.ReadResponse, _a1 error) *MockResourceClient_Read_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_Read_Call) RunAndReturn(run func(context.Context, *resourcepb.ReadRequest, ...grpc.CallOption) (*resourcepb.ReadResponse, error)) *MockResourceClient_Read_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RebuildIndexes provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) RebuildIndexes(ctx context.Context, in *resourcepb.RebuildIndexesRequest, opts ...grpc.CallOption) (*resourcepb.RebuildIndexesResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RebuildIndexes")
|
|
}
|
|
|
|
var r0 *resourcepb.RebuildIndexesResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.RebuildIndexesRequest, ...grpc.CallOption) (*resourcepb.RebuildIndexesResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.RebuildIndexesRequest, ...grpc.CallOption) *resourcepb.RebuildIndexesResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.RebuildIndexesResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.RebuildIndexesRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_RebuildIndexes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RebuildIndexes'
|
|
type MockResourceClient_RebuildIndexes_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RebuildIndexes is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.RebuildIndexesRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) RebuildIndexes(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_RebuildIndexes_Call {
|
|
return &MockResourceClient_RebuildIndexes_Call{Call: _e.mock.On("RebuildIndexes",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_RebuildIndexes_Call) Run(run func(ctx context.Context, in *resourcepb.RebuildIndexesRequest, opts ...grpc.CallOption)) *MockResourceClient_RebuildIndexes_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.RebuildIndexesRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_RebuildIndexes_Call) Return(_a0 *resourcepb.RebuildIndexesResponse, _a1 error) *MockResourceClient_RebuildIndexes_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_RebuildIndexes_Call) RunAndReturn(run func(context.Context, *resourcepb.RebuildIndexesRequest, ...grpc.CallOption) (*resourcepb.RebuildIndexesResponse, error)) *MockResourceClient_RebuildIndexes_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Search provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) Search(ctx context.Context, in *resourcepb.ResourceSearchRequest, opts ...grpc.CallOption) (*resourcepb.ResourceSearchResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Search")
|
|
}
|
|
|
|
var r0 *resourcepb.ResourceSearchResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ResourceSearchRequest, ...grpc.CallOption) (*resourcepb.ResourceSearchResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.ResourceSearchRequest, ...grpc.CallOption) *resourcepb.ResourceSearchResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.ResourceSearchResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.ResourceSearchRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
|
|
type MockResourceClient_Search_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Search is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.ResourceSearchRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) Search(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_Search_Call {
|
|
return &MockResourceClient_Search_Call{Call: _e.mock.On("Search",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_Search_Call) Run(run func(ctx context.Context, in *resourcepb.ResourceSearchRequest, opts ...grpc.CallOption)) *MockResourceClient_Search_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.ResourceSearchRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_Search_Call) Return(_a0 *resourcepb.ResourceSearchResponse, _a1 error) *MockResourceClient_Search_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_Search_Call) RunAndReturn(run func(context.Context, *resourcepb.ResourceSearchRequest, ...grpc.CallOption) (*resourcepb.ResourceSearchResponse, error)) *MockResourceClient_Search_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Update provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) Update(ctx context.Context, in *resourcepb.UpdateRequest, opts ...grpc.CallOption) (*resourcepb.UpdateResponse, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Update")
|
|
}
|
|
|
|
var r0 *resourcepb.UpdateResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.UpdateRequest, ...grpc.CallOption) (*resourcepb.UpdateResponse, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.UpdateRequest, ...grpc.CallOption) *resourcepb.UpdateResponse); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*resourcepb.UpdateResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.UpdateRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'
|
|
type MockResourceClient_Update_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Update is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.UpdateRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) Update(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_Update_Call {
|
|
return &MockResourceClient_Update_Call{Call: _e.mock.On("Update",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_Update_Call) Run(run func(ctx context.Context, in *resourcepb.UpdateRequest, opts ...grpc.CallOption)) *MockResourceClient_Update_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.UpdateRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_Update_Call) Return(_a0 *resourcepb.UpdateResponse, _a1 error) *MockResourceClient_Update_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_Update_Call) RunAndReturn(run func(context.Context, *resourcepb.UpdateRequest, ...grpc.CallOption) (*resourcepb.UpdateResponse, error)) *MockResourceClient_Update_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Watch provides a mock function with given fields: ctx, in, opts
|
|
func (_m *MockResourceClient) Watch(ctx context.Context, in *resourcepb.WatchRequest, opts ...grpc.CallOption) (resourcepb.ResourceStore_WatchClient, error) {
|
|
_va := make([]interface{}, len(opts))
|
|
for _i := range opts {
|
|
_va[_i] = opts[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, ctx, in)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Watch")
|
|
}
|
|
|
|
var r0 resourcepb.ResourceStore_WatchClient
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.WatchRequest, ...grpc.CallOption) (resourcepb.ResourceStore_WatchClient, error)); ok {
|
|
return rf(ctx, in, opts...)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, *resourcepb.WatchRequest, ...grpc.CallOption) resourcepb.ResourceStore_WatchClient); ok {
|
|
r0 = rf(ctx, in, opts...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(resourcepb.ResourceStore_WatchClient)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, *resourcepb.WatchRequest, ...grpc.CallOption) error); ok {
|
|
r1 = rf(ctx, in, opts...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockResourceClient_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch'
|
|
type MockResourceClient_Watch_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Watch is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - in *resourcepb.WatchRequest
|
|
// - opts ...grpc.CallOption
|
|
func (_e *MockResourceClient_Expecter) Watch(ctx interface{}, in interface{}, opts ...interface{}) *MockResourceClient_Watch_Call {
|
|
return &MockResourceClient_Watch_Call{Call: _e.mock.On("Watch",
|
|
append([]interface{}{ctx, in}, opts...)...)}
|
|
}
|
|
|
|
func (_c *MockResourceClient_Watch_Call) Run(run func(ctx context.Context, in *resourcepb.WatchRequest, opts ...grpc.CallOption)) *MockResourceClient_Watch_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
variadicArgs := make([]grpc.CallOption, len(args)-2)
|
|
for i, a := range args[2:] {
|
|
if a != nil {
|
|
variadicArgs[i] = a.(grpc.CallOption)
|
|
}
|
|
}
|
|
run(args[0].(context.Context), args[1].(*resourcepb.WatchRequest), variadicArgs...)
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_Watch_Call) Return(_a0 resourcepb.ResourceStore_WatchClient, _a1 error) *MockResourceClient_Watch_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockResourceClient_Watch_Call) RunAndReturn(run func(context.Context, *resourcepb.WatchRequest, ...grpc.CallOption) (resourcepb.ResourceStore_WatchClient, error)) *MockResourceClient_Watch_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockResourceClient creates a new instance of MockResourceClient. 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 NewMockResourceClient(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockResourceClient {
|
|
mock := &MockResourceClient{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|