mirror of https://github.com/grafana/grafana.git
1076 lines
37 KiB
Go
1076 lines
37 KiB
Go
// Code generated by mockery v2.53.4. 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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// 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
|
|
}
|