mirror of https://github.com/grafana/grafana
prometheushacktoberfestmetricsmonitoringalertinggrafanagoinfluxdbmysqlpostgresanalyticsdata-visualizationdashboardbusiness-intelligenceelasticsearch
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2779 lines
88 KiB
2779 lines
88 KiB
// Code generated by mockery v2.53.4. DO NOT EDIT.
|
|
|
|
package utils
|
|
|
|
import (
|
|
mock "github.com/stretchr/testify/mock"
|
|
runtime "k8s.io/apimachinery/pkg/runtime"
|
|
|
|
schema "k8s.io/apimachinery/pkg/runtime/schema"
|
|
|
|
time "time"
|
|
|
|
types "k8s.io/apimachinery/pkg/types"
|
|
|
|
v0alpha1 "github.com/grafana/grafana/pkg/apimachinery/apis/common/v0alpha1"
|
|
|
|
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
|
|
)
|
|
|
|
// MockGrafanaMetaAccessor is an autogenerated mock type for the GrafanaMetaAccessor type
|
|
type MockGrafanaMetaAccessor struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockGrafanaMetaAccessor_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockGrafanaMetaAccessor) EXPECT() *MockGrafanaMetaAccessor_Expecter {
|
|
return &MockGrafanaMetaAccessor_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// FindTitle provides a mock function with given fields: defaultTitle
|
|
func (_m *MockGrafanaMetaAccessor) FindTitle(defaultTitle string) string {
|
|
ret := _m.Called(defaultTitle)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for FindTitle")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func(string) string); ok {
|
|
r0 = rf(defaultTitle)
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_FindTitle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FindTitle'
|
|
type MockGrafanaMetaAccessor_FindTitle_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// FindTitle is a helper method to define mock.On call
|
|
// - defaultTitle string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) FindTitle(defaultTitle interface{}) *MockGrafanaMetaAccessor_FindTitle_Call {
|
|
return &MockGrafanaMetaAccessor_FindTitle_Call{Call: _e.mock.On("FindTitle", defaultTitle)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_FindTitle_Call) Run(run func(defaultTitle string)) *MockGrafanaMetaAccessor_FindTitle_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_FindTitle_Call) Return(_a0 string) *MockGrafanaMetaAccessor_FindTitle_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_FindTitle_Call) RunAndReturn(run func(string) string) *MockGrafanaMetaAccessor_FindTitle_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetAnnotation provides a mock function with given fields: key
|
|
func (_m *MockGrafanaMetaAccessor) GetAnnotation(key string) string {
|
|
ret := _m.Called(key)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetAnnotation")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func(string) string); ok {
|
|
r0 = rf(key)
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetAnnotation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAnnotation'
|
|
type MockGrafanaMetaAccessor_GetAnnotation_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetAnnotation is a helper method to define mock.On call
|
|
// - key string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetAnnotation(key interface{}) *MockGrafanaMetaAccessor_GetAnnotation_Call {
|
|
return &MockGrafanaMetaAccessor_GetAnnotation_Call{Call: _e.mock.On("GetAnnotation", key)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetAnnotation_Call) Run(run func(key string)) *MockGrafanaMetaAccessor_GetAnnotation_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetAnnotation_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetAnnotation_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetAnnotation_Call) RunAndReturn(run func(string) string) *MockGrafanaMetaAccessor_GetAnnotation_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetAnnotations provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetAnnotations() map[string]string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetAnnotations")
|
|
}
|
|
|
|
var r0 map[string]string
|
|
if rf, ok := ret.Get(0).(func() map[string]string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[string]string)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetAnnotations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAnnotations'
|
|
type MockGrafanaMetaAccessor_GetAnnotations_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetAnnotations is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetAnnotations() *MockGrafanaMetaAccessor_GetAnnotations_Call {
|
|
return &MockGrafanaMetaAccessor_GetAnnotations_Call{Call: _e.mock.On("GetAnnotations")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetAnnotations_Call) Run(run func()) *MockGrafanaMetaAccessor_GetAnnotations_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetAnnotations_Call) Return(_a0 map[string]string) *MockGrafanaMetaAccessor_GetAnnotations_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetAnnotations_Call) RunAndReturn(run func() map[string]string) *MockGrafanaMetaAccessor_GetAnnotations_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetBlob provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetBlob() *BlobInfo {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetBlob")
|
|
}
|
|
|
|
var r0 *BlobInfo
|
|
if rf, ok := ret.Get(0).(func() *BlobInfo); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*BlobInfo)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBlob'
|
|
type MockGrafanaMetaAccessor_GetBlob_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetBlob is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetBlob() *MockGrafanaMetaAccessor_GetBlob_Call {
|
|
return &MockGrafanaMetaAccessor_GetBlob_Call{Call: _e.mock.On("GetBlob")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetBlob_Call) Run(run func()) *MockGrafanaMetaAccessor_GetBlob_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetBlob_Call) Return(_a0 *BlobInfo) *MockGrafanaMetaAccessor_GetBlob_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetBlob_Call) RunAndReturn(run func() *BlobInfo) *MockGrafanaMetaAccessor_GetBlob_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetCreatedBy provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetCreatedBy() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetCreatedBy")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetCreatedBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCreatedBy'
|
|
type MockGrafanaMetaAccessor_GetCreatedBy_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCreatedBy is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetCreatedBy() *MockGrafanaMetaAccessor_GetCreatedBy_Call {
|
|
return &MockGrafanaMetaAccessor_GetCreatedBy_Call{Call: _e.mock.On("GetCreatedBy")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetCreatedBy_Call) Run(run func()) *MockGrafanaMetaAccessor_GetCreatedBy_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetCreatedBy_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetCreatedBy_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetCreatedBy_Call) RunAndReturn(run func() string) *MockGrafanaMetaAccessor_GetCreatedBy_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetCreationTimestamp provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetCreationTimestamp() v1.Time {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetCreationTimestamp")
|
|
}
|
|
|
|
var r0 v1.Time
|
|
if rf, ok := ret.Get(0).(func() v1.Time); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(v1.Time)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetCreationTimestamp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCreationTimestamp'
|
|
type MockGrafanaMetaAccessor_GetCreationTimestamp_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCreationTimestamp is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetCreationTimestamp() *MockGrafanaMetaAccessor_GetCreationTimestamp_Call {
|
|
return &MockGrafanaMetaAccessor_GetCreationTimestamp_Call{Call: _e.mock.On("GetCreationTimestamp")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetCreationTimestamp_Call) Run(run func()) *MockGrafanaMetaAccessor_GetCreationTimestamp_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetCreationTimestamp_Call) Return(_a0 v1.Time) *MockGrafanaMetaAccessor_GetCreationTimestamp_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetCreationTimestamp_Call) RunAndReturn(run func() v1.Time) *MockGrafanaMetaAccessor_GetCreationTimestamp_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetDeletionGracePeriodSeconds provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetDeletionGracePeriodSeconds() *int64 {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetDeletionGracePeriodSeconds")
|
|
}
|
|
|
|
var r0 *int64
|
|
if rf, ok := ret.Get(0).(func() *int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*int64)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDeletionGracePeriodSeconds'
|
|
type MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetDeletionGracePeriodSeconds is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetDeletionGracePeriodSeconds() *MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call {
|
|
return &MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call{Call: _e.mock.On("GetDeletionGracePeriodSeconds")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call) Run(run func()) *MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call) Return(_a0 *int64) *MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call) RunAndReturn(run func() *int64) *MockGrafanaMetaAccessor_GetDeletionGracePeriodSeconds_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetDeletionTimestamp provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetDeletionTimestamp() *v1.Time {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetDeletionTimestamp")
|
|
}
|
|
|
|
var r0 *v1.Time
|
|
if rf, ok := ret.Get(0).(func() *v1.Time); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*v1.Time)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetDeletionTimestamp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDeletionTimestamp'
|
|
type MockGrafanaMetaAccessor_GetDeletionTimestamp_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetDeletionTimestamp is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetDeletionTimestamp() *MockGrafanaMetaAccessor_GetDeletionTimestamp_Call {
|
|
return &MockGrafanaMetaAccessor_GetDeletionTimestamp_Call{Call: _e.mock.On("GetDeletionTimestamp")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetDeletionTimestamp_Call) Run(run func()) *MockGrafanaMetaAccessor_GetDeletionTimestamp_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetDeletionTimestamp_Call) Return(_a0 *v1.Time) *MockGrafanaMetaAccessor_GetDeletionTimestamp_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetDeletionTimestamp_Call) RunAndReturn(run func() *v1.Time) *MockGrafanaMetaAccessor_GetDeletionTimestamp_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetDeprecatedInternalID provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetDeprecatedInternalID() int64 {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetDeprecatedInternalID")
|
|
}
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDeprecatedInternalID'
|
|
type MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetDeprecatedInternalID is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetDeprecatedInternalID() *MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call {
|
|
return &MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call{Call: _e.mock.On("GetDeprecatedInternalID")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call) Run(run func()) *MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call) Return(_a0 int64) *MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call) RunAndReturn(run func() int64) *MockGrafanaMetaAccessor_GetDeprecatedInternalID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetFinalizers provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetFinalizers() []string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetFinalizers")
|
|
}
|
|
|
|
var r0 []string
|
|
if rf, ok := ret.Get(0).(func() []string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]string)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetFinalizers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFinalizers'
|
|
type MockGrafanaMetaAccessor_GetFinalizers_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetFinalizers is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetFinalizers() *MockGrafanaMetaAccessor_GetFinalizers_Call {
|
|
return &MockGrafanaMetaAccessor_GetFinalizers_Call{Call: _e.mock.On("GetFinalizers")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetFinalizers_Call) Run(run func()) *MockGrafanaMetaAccessor_GetFinalizers_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetFinalizers_Call) Return(_a0 []string) *MockGrafanaMetaAccessor_GetFinalizers_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetFinalizers_Call) RunAndReturn(run func() []string) *MockGrafanaMetaAccessor_GetFinalizers_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetFolder provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetFolder() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetFolder")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetFolder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFolder'
|
|
type MockGrafanaMetaAccessor_GetFolder_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetFolder is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetFolder() *MockGrafanaMetaAccessor_GetFolder_Call {
|
|
return &MockGrafanaMetaAccessor_GetFolder_Call{Call: _e.mock.On("GetFolder")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetFolder_Call) Run(run func()) *MockGrafanaMetaAccessor_GetFolder_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetFolder_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetFolder_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetFolder_Call) RunAndReturn(run func() string) *MockGrafanaMetaAccessor_GetFolder_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetFullpath provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetFullpath() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetFullpath")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetFullpath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFullpath'
|
|
type MockGrafanaMetaAccessor_GetFullpath_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetFullpath is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetFullpath() *MockGrafanaMetaAccessor_GetFullpath_Call {
|
|
return &MockGrafanaMetaAccessor_GetFullpath_Call{Call: _e.mock.On("GetFullpath")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetFullpath_Call) Run(run func()) *MockGrafanaMetaAccessor_GetFullpath_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetFullpath_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetFullpath_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetFullpath_Call) RunAndReturn(run func() string) *MockGrafanaMetaAccessor_GetFullpath_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetFullpathUIDs provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetFullpathUIDs() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetFullpathUIDs")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetFullpathUIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFullpathUIDs'
|
|
type MockGrafanaMetaAccessor_GetFullpathUIDs_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetFullpathUIDs is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetFullpathUIDs() *MockGrafanaMetaAccessor_GetFullpathUIDs_Call {
|
|
return &MockGrafanaMetaAccessor_GetFullpathUIDs_Call{Call: _e.mock.On("GetFullpathUIDs")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetFullpathUIDs_Call) Run(run func()) *MockGrafanaMetaAccessor_GetFullpathUIDs_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetFullpathUIDs_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetFullpathUIDs_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetFullpathUIDs_Call) RunAndReturn(run func() string) *MockGrafanaMetaAccessor_GetFullpathUIDs_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetGenerateName provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetGenerateName() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGenerateName")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetGenerateName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGenerateName'
|
|
type MockGrafanaMetaAccessor_GetGenerateName_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetGenerateName is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetGenerateName() *MockGrafanaMetaAccessor_GetGenerateName_Call {
|
|
return &MockGrafanaMetaAccessor_GetGenerateName_Call{Call: _e.mock.On("GetGenerateName")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetGenerateName_Call) Run(run func()) *MockGrafanaMetaAccessor_GetGenerateName_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetGenerateName_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetGenerateName_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetGenerateName_Call) RunAndReturn(run func() string) *MockGrafanaMetaAccessor_GetGenerateName_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetGeneration provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetGeneration() int64 {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGeneration")
|
|
}
|
|
|
|
var r0 int64
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetGeneration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGeneration'
|
|
type MockGrafanaMetaAccessor_GetGeneration_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetGeneration is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetGeneration() *MockGrafanaMetaAccessor_GetGeneration_Call {
|
|
return &MockGrafanaMetaAccessor_GetGeneration_Call{Call: _e.mock.On("GetGeneration")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetGeneration_Call) Run(run func()) *MockGrafanaMetaAccessor_GetGeneration_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetGeneration_Call) Return(_a0 int64) *MockGrafanaMetaAccessor_GetGeneration_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetGeneration_Call) RunAndReturn(run func() int64) *MockGrafanaMetaAccessor_GetGeneration_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetGroupVersionKind provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetGroupVersionKind() schema.GroupVersionKind {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetGroupVersionKind")
|
|
}
|
|
|
|
var r0 schema.GroupVersionKind
|
|
if rf, ok := ret.Get(0).(func() schema.GroupVersionKind); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(schema.GroupVersionKind)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetGroupVersionKind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetGroupVersionKind'
|
|
type MockGrafanaMetaAccessor_GetGroupVersionKind_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetGroupVersionKind is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetGroupVersionKind() *MockGrafanaMetaAccessor_GetGroupVersionKind_Call {
|
|
return &MockGrafanaMetaAccessor_GetGroupVersionKind_Call{Call: _e.mock.On("GetGroupVersionKind")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetGroupVersionKind_Call) Run(run func()) *MockGrafanaMetaAccessor_GetGroupVersionKind_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetGroupVersionKind_Call) Return(_a0 schema.GroupVersionKind) *MockGrafanaMetaAccessor_GetGroupVersionKind_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetGroupVersionKind_Call) RunAndReturn(run func() schema.GroupVersionKind) *MockGrafanaMetaAccessor_GetGroupVersionKind_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetLabels provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetLabels() map[string]string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetLabels")
|
|
}
|
|
|
|
var r0 map[string]string
|
|
if rf, ok := ret.Get(0).(func() map[string]string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[string]string)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLabels'
|
|
type MockGrafanaMetaAccessor_GetLabels_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetLabels is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetLabels() *MockGrafanaMetaAccessor_GetLabels_Call {
|
|
return &MockGrafanaMetaAccessor_GetLabels_Call{Call: _e.mock.On("GetLabels")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetLabels_Call) Run(run func()) *MockGrafanaMetaAccessor_GetLabels_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetLabels_Call) Return(_a0 map[string]string) *MockGrafanaMetaAccessor_GetLabels_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetLabels_Call) RunAndReturn(run func() map[string]string) *MockGrafanaMetaAccessor_GetLabels_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetManagedFields provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetManagedFields() []v1.ManagedFieldsEntry {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetManagedFields")
|
|
}
|
|
|
|
var r0 []v1.ManagedFieldsEntry
|
|
if rf, ok := ret.Get(0).(func() []v1.ManagedFieldsEntry); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]v1.ManagedFieldsEntry)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetManagedFields_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetManagedFields'
|
|
type MockGrafanaMetaAccessor_GetManagedFields_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetManagedFields is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetManagedFields() *MockGrafanaMetaAccessor_GetManagedFields_Call {
|
|
return &MockGrafanaMetaAccessor_GetManagedFields_Call{Call: _e.mock.On("GetManagedFields")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetManagedFields_Call) Run(run func()) *MockGrafanaMetaAccessor_GetManagedFields_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetManagedFields_Call) Return(_a0 []v1.ManagedFieldsEntry) *MockGrafanaMetaAccessor_GetManagedFields_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetManagedFields_Call) RunAndReturn(run func() []v1.ManagedFieldsEntry) *MockGrafanaMetaAccessor_GetManagedFields_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetManagerProperties provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetManagerProperties() (ManagerProperties, bool) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetManagerProperties")
|
|
}
|
|
|
|
var r0 ManagerProperties
|
|
var r1 bool
|
|
if rf, ok := ret.Get(0).(func() (ManagerProperties, bool)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() ManagerProperties); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(ManagerProperties)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() bool); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Get(1).(bool)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetManagerProperties_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetManagerProperties'
|
|
type MockGrafanaMetaAccessor_GetManagerProperties_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetManagerProperties is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetManagerProperties() *MockGrafanaMetaAccessor_GetManagerProperties_Call {
|
|
return &MockGrafanaMetaAccessor_GetManagerProperties_Call{Call: _e.mock.On("GetManagerProperties")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetManagerProperties_Call) Run(run func()) *MockGrafanaMetaAccessor_GetManagerProperties_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetManagerProperties_Call) Return(_a0 ManagerProperties, _a1 bool) *MockGrafanaMetaAccessor_GetManagerProperties_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetManagerProperties_Call) RunAndReturn(run func() (ManagerProperties, bool)) *MockGrafanaMetaAccessor_GetManagerProperties_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetMessage provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetMessage() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetMessage")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetMessage'
|
|
type MockGrafanaMetaAccessor_GetMessage_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetMessage is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetMessage() *MockGrafanaMetaAccessor_GetMessage_Call {
|
|
return &MockGrafanaMetaAccessor_GetMessage_Call{Call: _e.mock.On("GetMessage")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetMessage_Call) Run(run func()) *MockGrafanaMetaAccessor_GetMessage_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetMessage_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetMessage_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetMessage_Call) RunAndReturn(run func() string) *MockGrafanaMetaAccessor_GetMessage_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetName provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetName() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetName")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetName'
|
|
type MockGrafanaMetaAccessor_GetName_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetName is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetName() *MockGrafanaMetaAccessor_GetName_Call {
|
|
return &MockGrafanaMetaAccessor_GetName_Call{Call: _e.mock.On("GetName")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetName_Call) Run(run func()) *MockGrafanaMetaAccessor_GetName_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetName_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetName_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetName_Call) RunAndReturn(run func() string) *MockGrafanaMetaAccessor_GetName_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetNamespace provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetNamespace() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetNamespace")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetNamespace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNamespace'
|
|
type MockGrafanaMetaAccessor_GetNamespace_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetNamespace is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetNamespace() *MockGrafanaMetaAccessor_GetNamespace_Call {
|
|
return &MockGrafanaMetaAccessor_GetNamespace_Call{Call: _e.mock.On("GetNamespace")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetNamespace_Call) Run(run func()) *MockGrafanaMetaAccessor_GetNamespace_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetNamespace_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetNamespace_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetNamespace_Call) RunAndReturn(run func() string) *MockGrafanaMetaAccessor_GetNamespace_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetOwnerReferences provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetOwnerReferences() []v1.OwnerReference {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetOwnerReferences")
|
|
}
|
|
|
|
var r0 []v1.OwnerReference
|
|
if rf, ok := ret.Get(0).(func() []v1.OwnerReference); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]v1.OwnerReference)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetOwnerReferences_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOwnerReferences'
|
|
type MockGrafanaMetaAccessor_GetOwnerReferences_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetOwnerReferences is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetOwnerReferences() *MockGrafanaMetaAccessor_GetOwnerReferences_Call {
|
|
return &MockGrafanaMetaAccessor_GetOwnerReferences_Call{Call: _e.mock.On("GetOwnerReferences")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetOwnerReferences_Call) Run(run func()) *MockGrafanaMetaAccessor_GetOwnerReferences_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetOwnerReferences_Call) Return(_a0 []v1.OwnerReference) *MockGrafanaMetaAccessor_GetOwnerReferences_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetOwnerReferences_Call) RunAndReturn(run func() []v1.OwnerReference) *MockGrafanaMetaAccessor_GetOwnerReferences_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetResourceVersion provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetResourceVersion() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetResourceVersion")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetResourceVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResourceVersion'
|
|
type MockGrafanaMetaAccessor_GetResourceVersion_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetResourceVersion is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetResourceVersion() *MockGrafanaMetaAccessor_GetResourceVersion_Call {
|
|
return &MockGrafanaMetaAccessor_GetResourceVersion_Call{Call: _e.mock.On("GetResourceVersion")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetResourceVersion_Call) Run(run func()) *MockGrafanaMetaAccessor_GetResourceVersion_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetResourceVersion_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetResourceVersion_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetResourceVersion_Call) RunAndReturn(run func() string) *MockGrafanaMetaAccessor_GetResourceVersion_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetResourceVersionInt64 provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetResourceVersionInt64() (int64, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetResourceVersionInt64")
|
|
}
|
|
|
|
var r0 int64
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (int64, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() int64); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(int64)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetResourceVersionInt64_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetResourceVersionInt64'
|
|
type MockGrafanaMetaAccessor_GetResourceVersionInt64_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetResourceVersionInt64 is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetResourceVersionInt64() *MockGrafanaMetaAccessor_GetResourceVersionInt64_Call {
|
|
return &MockGrafanaMetaAccessor_GetResourceVersionInt64_Call{Call: _e.mock.On("GetResourceVersionInt64")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetResourceVersionInt64_Call) Run(run func()) *MockGrafanaMetaAccessor_GetResourceVersionInt64_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetResourceVersionInt64_Call) Return(_a0 int64, _a1 error) *MockGrafanaMetaAccessor_GetResourceVersionInt64_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetResourceVersionInt64_Call) RunAndReturn(run func() (int64, error)) *MockGrafanaMetaAccessor_GetResourceVersionInt64_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetRuntimeObject provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetRuntimeObject() (runtime.Object, bool) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetRuntimeObject")
|
|
}
|
|
|
|
var r0 runtime.Object
|
|
var r1 bool
|
|
if rf, ok := ret.Get(0).(func() (runtime.Object, bool)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() runtime.Object); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(runtime.Object)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() bool); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Get(1).(bool)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetRuntimeObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRuntimeObject'
|
|
type MockGrafanaMetaAccessor_GetRuntimeObject_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetRuntimeObject is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetRuntimeObject() *MockGrafanaMetaAccessor_GetRuntimeObject_Call {
|
|
return &MockGrafanaMetaAccessor_GetRuntimeObject_Call{Call: _e.mock.On("GetRuntimeObject")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetRuntimeObject_Call) Run(run func()) *MockGrafanaMetaAccessor_GetRuntimeObject_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetRuntimeObject_Call) Return(_a0 runtime.Object, _a1 bool) *MockGrafanaMetaAccessor_GetRuntimeObject_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetRuntimeObject_Call) RunAndReturn(run func() (runtime.Object, bool)) *MockGrafanaMetaAccessor_GetRuntimeObject_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSecureValues provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetSecureValues() (map[string]v0alpha1.InlineSecureValue, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSecureValues")
|
|
}
|
|
|
|
var r0 map[string]v0alpha1.InlineSecureValue
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (map[string]v0alpha1.InlineSecureValue, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() map[string]v0alpha1.InlineSecureValue); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(map[string]v0alpha1.InlineSecureValue)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetSecureValues_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSecureValues'
|
|
type MockGrafanaMetaAccessor_GetSecureValues_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSecureValues is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetSecureValues() *MockGrafanaMetaAccessor_GetSecureValues_Call {
|
|
return &MockGrafanaMetaAccessor_GetSecureValues_Call{Call: _e.mock.On("GetSecureValues")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetSecureValues_Call) Run(run func()) *MockGrafanaMetaAccessor_GetSecureValues_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetSecureValues_Call) Return(_a0 map[string]v0alpha1.InlineSecureValue, _a1 error) *MockGrafanaMetaAccessor_GetSecureValues_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetSecureValues_Call) RunAndReturn(run func() (map[string]v0alpha1.InlineSecureValue, error)) *MockGrafanaMetaAccessor_GetSecureValues_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSelfLink provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetSelfLink() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSelfLink")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetSelfLink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSelfLink'
|
|
type MockGrafanaMetaAccessor_GetSelfLink_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSelfLink is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetSelfLink() *MockGrafanaMetaAccessor_GetSelfLink_Call {
|
|
return &MockGrafanaMetaAccessor_GetSelfLink_Call{Call: _e.mock.On("GetSelfLink")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetSelfLink_Call) Run(run func()) *MockGrafanaMetaAccessor_GetSelfLink_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetSelfLink_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetSelfLink_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetSelfLink_Call) RunAndReturn(run func() string) *MockGrafanaMetaAccessor_GetSelfLink_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSourceProperties provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetSourceProperties() (SourceProperties, bool) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSourceProperties")
|
|
}
|
|
|
|
var r0 SourceProperties
|
|
var r1 bool
|
|
if rf, ok := ret.Get(0).(func() (SourceProperties, bool)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() SourceProperties); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(SourceProperties)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() bool); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Get(1).(bool)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetSourceProperties_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSourceProperties'
|
|
type MockGrafanaMetaAccessor_GetSourceProperties_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSourceProperties is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetSourceProperties() *MockGrafanaMetaAccessor_GetSourceProperties_Call {
|
|
return &MockGrafanaMetaAccessor_GetSourceProperties_Call{Call: _e.mock.On("GetSourceProperties")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetSourceProperties_Call) Run(run func()) *MockGrafanaMetaAccessor_GetSourceProperties_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetSourceProperties_Call) Return(_a0 SourceProperties, _a1 bool) *MockGrafanaMetaAccessor_GetSourceProperties_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetSourceProperties_Call) RunAndReturn(run func() (SourceProperties, bool)) *MockGrafanaMetaAccessor_GetSourceProperties_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSpec provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetSpec() (interface{}, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSpec")
|
|
}
|
|
|
|
var r0 interface{}
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (interface{}, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() interface{}); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(interface{})
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetSpec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSpec'
|
|
type MockGrafanaMetaAccessor_GetSpec_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSpec is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetSpec() *MockGrafanaMetaAccessor_GetSpec_Call {
|
|
return &MockGrafanaMetaAccessor_GetSpec_Call{Call: _e.mock.On("GetSpec")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetSpec_Call) Run(run func()) *MockGrafanaMetaAccessor_GetSpec_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetSpec_Call) Return(_a0 interface{}, _a1 error) *MockGrafanaMetaAccessor_GetSpec_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetSpec_Call) RunAndReturn(run func() (interface{}, error)) *MockGrafanaMetaAccessor_GetSpec_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetStatus provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetStatus() (interface{}, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetStatus")
|
|
}
|
|
|
|
var r0 interface{}
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (interface{}, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() interface{}); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(interface{})
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetStatus'
|
|
type MockGrafanaMetaAccessor_GetStatus_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetStatus is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetStatus() *MockGrafanaMetaAccessor_GetStatus_Call {
|
|
return &MockGrafanaMetaAccessor_GetStatus_Call{Call: _e.mock.On("GetStatus")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetStatus_Call) Run(run func()) *MockGrafanaMetaAccessor_GetStatus_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetStatus_Call) Return(_a0 interface{}, _a1 error) *MockGrafanaMetaAccessor_GetStatus_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetStatus_Call) RunAndReturn(run func() (interface{}, error)) *MockGrafanaMetaAccessor_GetStatus_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetUID provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetUID() types.UID {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUID")
|
|
}
|
|
|
|
var r0 types.UID
|
|
if rf, ok := ret.Get(0).(func() types.UID); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(types.UID)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUID'
|
|
type MockGrafanaMetaAccessor_GetUID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetUID is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetUID() *MockGrafanaMetaAccessor_GetUID_Call {
|
|
return &MockGrafanaMetaAccessor_GetUID_Call{Call: _e.mock.On("GetUID")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetUID_Call) Run(run func()) *MockGrafanaMetaAccessor_GetUID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetUID_Call) Return(_a0 types.UID) *MockGrafanaMetaAccessor_GetUID_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetUID_Call) RunAndReturn(run func() types.UID) *MockGrafanaMetaAccessor_GetUID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetUpdatedBy provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetUpdatedBy() string {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUpdatedBy")
|
|
}
|
|
|
|
var r0 string
|
|
if rf, ok := ret.Get(0).(func() string); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetUpdatedBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUpdatedBy'
|
|
type MockGrafanaMetaAccessor_GetUpdatedBy_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetUpdatedBy is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetUpdatedBy() *MockGrafanaMetaAccessor_GetUpdatedBy_Call {
|
|
return &MockGrafanaMetaAccessor_GetUpdatedBy_Call{Call: _e.mock.On("GetUpdatedBy")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetUpdatedBy_Call) Run(run func()) *MockGrafanaMetaAccessor_GetUpdatedBy_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetUpdatedBy_Call) Return(_a0 string) *MockGrafanaMetaAccessor_GetUpdatedBy_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetUpdatedBy_Call) RunAndReturn(run func() string) *MockGrafanaMetaAccessor_GetUpdatedBy_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetUpdatedTimestamp provides a mock function with no fields
|
|
func (_m *MockGrafanaMetaAccessor) GetUpdatedTimestamp() (*time.Time, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUpdatedTimestamp")
|
|
}
|
|
|
|
var r0 *time.Time
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (*time.Time, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() *time.Time); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*time.Time)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUpdatedTimestamp'
|
|
type MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetUpdatedTimestamp is a helper method to define mock.On call
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) GetUpdatedTimestamp() *MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call {
|
|
return &MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call{Call: _e.mock.On("GetUpdatedTimestamp")}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call) Run(run func()) *MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call) Return(_a0 *time.Time, _a1 error) *MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call) RunAndReturn(run func() (*time.Time, error)) *MockGrafanaMetaAccessor_GetUpdatedTimestamp_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetAnnotation provides a mock function with given fields: key, val
|
|
func (_m *MockGrafanaMetaAccessor) SetAnnotation(key string, val string) {
|
|
_m.Called(key, val)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetAnnotation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAnnotation'
|
|
type MockGrafanaMetaAccessor_SetAnnotation_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetAnnotation is a helper method to define mock.On call
|
|
// - key string
|
|
// - val string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetAnnotation(key interface{}, val interface{}) *MockGrafanaMetaAccessor_SetAnnotation_Call {
|
|
return &MockGrafanaMetaAccessor_SetAnnotation_Call{Call: _e.mock.On("SetAnnotation", key, val)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetAnnotation_Call) Run(run func(key string, val string)) *MockGrafanaMetaAccessor_SetAnnotation_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetAnnotation_Call) Return() *MockGrafanaMetaAccessor_SetAnnotation_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetAnnotation_Call) RunAndReturn(run func(string, string)) *MockGrafanaMetaAccessor_SetAnnotation_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetAnnotations provides a mock function with given fields: annotations
|
|
func (_m *MockGrafanaMetaAccessor) SetAnnotations(annotations map[string]string) {
|
|
_m.Called(annotations)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetAnnotations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAnnotations'
|
|
type MockGrafanaMetaAccessor_SetAnnotations_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetAnnotations is a helper method to define mock.On call
|
|
// - annotations map[string]string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetAnnotations(annotations interface{}) *MockGrafanaMetaAccessor_SetAnnotations_Call {
|
|
return &MockGrafanaMetaAccessor_SetAnnotations_Call{Call: _e.mock.On("SetAnnotations", annotations)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetAnnotations_Call) Run(run func(annotations map[string]string)) *MockGrafanaMetaAccessor_SetAnnotations_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(map[string]string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetAnnotations_Call) Return() *MockGrafanaMetaAccessor_SetAnnotations_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetAnnotations_Call) RunAndReturn(run func(map[string]string)) *MockGrafanaMetaAccessor_SetAnnotations_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetBlob provides a mock function with given fields: v
|
|
func (_m *MockGrafanaMetaAccessor) SetBlob(v *BlobInfo) {
|
|
_m.Called(v)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetBlob'
|
|
type MockGrafanaMetaAccessor_SetBlob_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetBlob is a helper method to define mock.On call
|
|
// - v *BlobInfo
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetBlob(v interface{}) *MockGrafanaMetaAccessor_SetBlob_Call {
|
|
return &MockGrafanaMetaAccessor_SetBlob_Call{Call: _e.mock.On("SetBlob", v)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetBlob_Call) Run(run func(v *BlobInfo)) *MockGrafanaMetaAccessor_SetBlob_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*BlobInfo))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetBlob_Call) Return() *MockGrafanaMetaAccessor_SetBlob_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetBlob_Call) RunAndReturn(run func(*BlobInfo)) *MockGrafanaMetaAccessor_SetBlob_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetCreatedBy provides a mock function with given fields: user
|
|
func (_m *MockGrafanaMetaAccessor) SetCreatedBy(user string) {
|
|
_m.Called(user)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetCreatedBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCreatedBy'
|
|
type MockGrafanaMetaAccessor_SetCreatedBy_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetCreatedBy is a helper method to define mock.On call
|
|
// - user string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetCreatedBy(user interface{}) *MockGrafanaMetaAccessor_SetCreatedBy_Call {
|
|
return &MockGrafanaMetaAccessor_SetCreatedBy_Call{Call: _e.mock.On("SetCreatedBy", user)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetCreatedBy_Call) Run(run func(user string)) *MockGrafanaMetaAccessor_SetCreatedBy_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetCreatedBy_Call) Return() *MockGrafanaMetaAccessor_SetCreatedBy_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetCreatedBy_Call) RunAndReturn(run func(string)) *MockGrafanaMetaAccessor_SetCreatedBy_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetCreationTimestamp provides a mock function with given fields: timestamp
|
|
func (_m *MockGrafanaMetaAccessor) SetCreationTimestamp(timestamp v1.Time) {
|
|
_m.Called(timestamp)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetCreationTimestamp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCreationTimestamp'
|
|
type MockGrafanaMetaAccessor_SetCreationTimestamp_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetCreationTimestamp is a helper method to define mock.On call
|
|
// - timestamp v1.Time
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetCreationTimestamp(timestamp interface{}) *MockGrafanaMetaAccessor_SetCreationTimestamp_Call {
|
|
return &MockGrafanaMetaAccessor_SetCreationTimestamp_Call{Call: _e.mock.On("SetCreationTimestamp", timestamp)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetCreationTimestamp_Call) Run(run func(timestamp v1.Time)) *MockGrafanaMetaAccessor_SetCreationTimestamp_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(v1.Time))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetCreationTimestamp_Call) Return() *MockGrafanaMetaAccessor_SetCreationTimestamp_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetCreationTimestamp_Call) RunAndReturn(run func(v1.Time)) *MockGrafanaMetaAccessor_SetCreationTimestamp_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetDeletionGracePeriodSeconds provides a mock function with given fields: _a0
|
|
func (_m *MockGrafanaMetaAccessor) SetDeletionGracePeriodSeconds(_a0 *int64) {
|
|
_m.Called(_a0)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDeletionGracePeriodSeconds'
|
|
type MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetDeletionGracePeriodSeconds is a helper method to define mock.On call
|
|
// - _a0 *int64
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetDeletionGracePeriodSeconds(_a0 interface{}) *MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call {
|
|
return &MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call{Call: _e.mock.On("SetDeletionGracePeriodSeconds", _a0)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call) Run(run func(_a0 *int64)) *MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call) Return() *MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call) RunAndReturn(run func(*int64)) *MockGrafanaMetaAccessor_SetDeletionGracePeriodSeconds_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetDeletionTimestamp provides a mock function with given fields: timestamp
|
|
func (_m *MockGrafanaMetaAccessor) SetDeletionTimestamp(timestamp *v1.Time) {
|
|
_m.Called(timestamp)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetDeletionTimestamp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDeletionTimestamp'
|
|
type MockGrafanaMetaAccessor_SetDeletionTimestamp_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetDeletionTimestamp is a helper method to define mock.On call
|
|
// - timestamp *v1.Time
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetDeletionTimestamp(timestamp interface{}) *MockGrafanaMetaAccessor_SetDeletionTimestamp_Call {
|
|
return &MockGrafanaMetaAccessor_SetDeletionTimestamp_Call{Call: _e.mock.On("SetDeletionTimestamp", timestamp)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetDeletionTimestamp_Call) Run(run func(timestamp *v1.Time)) *MockGrafanaMetaAccessor_SetDeletionTimestamp_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*v1.Time))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetDeletionTimestamp_Call) Return() *MockGrafanaMetaAccessor_SetDeletionTimestamp_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetDeletionTimestamp_Call) RunAndReturn(run func(*v1.Time)) *MockGrafanaMetaAccessor_SetDeletionTimestamp_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetDeprecatedInternalID provides a mock function with given fields: id
|
|
func (_m *MockGrafanaMetaAccessor) SetDeprecatedInternalID(id int64) {
|
|
_m.Called(id)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDeprecatedInternalID'
|
|
type MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetDeprecatedInternalID is a helper method to define mock.On call
|
|
// - id int64
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetDeprecatedInternalID(id interface{}) *MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call {
|
|
return &MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call{Call: _e.mock.On("SetDeprecatedInternalID", id)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call) Run(run func(id int64)) *MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call) Return() *MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call) RunAndReturn(run func(int64)) *MockGrafanaMetaAccessor_SetDeprecatedInternalID_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetFinalizers provides a mock function with given fields: finalizers
|
|
func (_m *MockGrafanaMetaAccessor) SetFinalizers(finalizers []string) {
|
|
_m.Called(finalizers)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetFinalizers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFinalizers'
|
|
type MockGrafanaMetaAccessor_SetFinalizers_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetFinalizers is a helper method to define mock.On call
|
|
// - finalizers []string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetFinalizers(finalizers interface{}) *MockGrafanaMetaAccessor_SetFinalizers_Call {
|
|
return &MockGrafanaMetaAccessor_SetFinalizers_Call{Call: _e.mock.On("SetFinalizers", finalizers)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetFinalizers_Call) Run(run func(finalizers []string)) *MockGrafanaMetaAccessor_SetFinalizers_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].([]string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetFinalizers_Call) Return() *MockGrafanaMetaAccessor_SetFinalizers_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetFinalizers_Call) RunAndReturn(run func([]string)) *MockGrafanaMetaAccessor_SetFinalizers_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetFolder provides a mock function with given fields: uid
|
|
func (_m *MockGrafanaMetaAccessor) SetFolder(uid string) {
|
|
_m.Called(uid)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetFolder_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFolder'
|
|
type MockGrafanaMetaAccessor_SetFolder_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetFolder is a helper method to define mock.On call
|
|
// - uid string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetFolder(uid interface{}) *MockGrafanaMetaAccessor_SetFolder_Call {
|
|
return &MockGrafanaMetaAccessor_SetFolder_Call{Call: _e.mock.On("SetFolder", uid)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetFolder_Call) Run(run func(uid string)) *MockGrafanaMetaAccessor_SetFolder_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetFolder_Call) Return() *MockGrafanaMetaAccessor_SetFolder_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetFolder_Call) RunAndReturn(run func(string)) *MockGrafanaMetaAccessor_SetFolder_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetFullpath provides a mock function with given fields: path
|
|
func (_m *MockGrafanaMetaAccessor) SetFullpath(path string) {
|
|
_m.Called(path)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetFullpath_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFullpath'
|
|
type MockGrafanaMetaAccessor_SetFullpath_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetFullpath is a helper method to define mock.On call
|
|
// - path string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetFullpath(path interface{}) *MockGrafanaMetaAccessor_SetFullpath_Call {
|
|
return &MockGrafanaMetaAccessor_SetFullpath_Call{Call: _e.mock.On("SetFullpath", path)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetFullpath_Call) Run(run func(path string)) *MockGrafanaMetaAccessor_SetFullpath_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetFullpath_Call) Return() *MockGrafanaMetaAccessor_SetFullpath_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetFullpath_Call) RunAndReturn(run func(string)) *MockGrafanaMetaAccessor_SetFullpath_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetFullpathUIDs provides a mock function with given fields: uids
|
|
func (_m *MockGrafanaMetaAccessor) SetFullpathUIDs(uids string) {
|
|
_m.Called(uids)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetFullpathUIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFullpathUIDs'
|
|
type MockGrafanaMetaAccessor_SetFullpathUIDs_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetFullpathUIDs is a helper method to define mock.On call
|
|
// - uids string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetFullpathUIDs(uids interface{}) *MockGrafanaMetaAccessor_SetFullpathUIDs_Call {
|
|
return &MockGrafanaMetaAccessor_SetFullpathUIDs_Call{Call: _e.mock.On("SetFullpathUIDs", uids)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetFullpathUIDs_Call) Run(run func(uids string)) *MockGrafanaMetaAccessor_SetFullpathUIDs_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetFullpathUIDs_Call) Return() *MockGrafanaMetaAccessor_SetFullpathUIDs_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetFullpathUIDs_Call) RunAndReturn(run func(string)) *MockGrafanaMetaAccessor_SetFullpathUIDs_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetGenerateName provides a mock function with given fields: name
|
|
func (_m *MockGrafanaMetaAccessor) SetGenerateName(name string) {
|
|
_m.Called(name)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetGenerateName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetGenerateName'
|
|
type MockGrafanaMetaAccessor_SetGenerateName_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetGenerateName is a helper method to define mock.On call
|
|
// - name string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetGenerateName(name interface{}) *MockGrafanaMetaAccessor_SetGenerateName_Call {
|
|
return &MockGrafanaMetaAccessor_SetGenerateName_Call{Call: _e.mock.On("SetGenerateName", name)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetGenerateName_Call) Run(run func(name string)) *MockGrafanaMetaAccessor_SetGenerateName_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetGenerateName_Call) Return() *MockGrafanaMetaAccessor_SetGenerateName_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetGenerateName_Call) RunAndReturn(run func(string)) *MockGrafanaMetaAccessor_SetGenerateName_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetGeneration provides a mock function with given fields: generation
|
|
func (_m *MockGrafanaMetaAccessor) SetGeneration(generation int64) {
|
|
_m.Called(generation)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetGeneration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetGeneration'
|
|
type MockGrafanaMetaAccessor_SetGeneration_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetGeneration is a helper method to define mock.On call
|
|
// - generation int64
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetGeneration(generation interface{}) *MockGrafanaMetaAccessor_SetGeneration_Call {
|
|
return &MockGrafanaMetaAccessor_SetGeneration_Call{Call: _e.mock.On("SetGeneration", generation)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetGeneration_Call) Run(run func(generation int64)) *MockGrafanaMetaAccessor_SetGeneration_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetGeneration_Call) Return() *MockGrafanaMetaAccessor_SetGeneration_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetGeneration_Call) RunAndReturn(run func(int64)) *MockGrafanaMetaAccessor_SetGeneration_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetLabels provides a mock function with given fields: labels
|
|
func (_m *MockGrafanaMetaAccessor) SetLabels(labels map[string]string) {
|
|
_m.Called(labels)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetLabels_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLabels'
|
|
type MockGrafanaMetaAccessor_SetLabels_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetLabels is a helper method to define mock.On call
|
|
// - labels map[string]string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetLabels(labels interface{}) *MockGrafanaMetaAccessor_SetLabels_Call {
|
|
return &MockGrafanaMetaAccessor_SetLabels_Call{Call: _e.mock.On("SetLabels", labels)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetLabels_Call) Run(run func(labels map[string]string)) *MockGrafanaMetaAccessor_SetLabels_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(map[string]string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetLabels_Call) Return() *MockGrafanaMetaAccessor_SetLabels_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetLabels_Call) RunAndReturn(run func(map[string]string)) *MockGrafanaMetaAccessor_SetLabels_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetManagedFields provides a mock function with given fields: managedFields
|
|
func (_m *MockGrafanaMetaAccessor) SetManagedFields(managedFields []v1.ManagedFieldsEntry) {
|
|
_m.Called(managedFields)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetManagedFields_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetManagedFields'
|
|
type MockGrafanaMetaAccessor_SetManagedFields_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetManagedFields is a helper method to define mock.On call
|
|
// - managedFields []v1.ManagedFieldsEntry
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetManagedFields(managedFields interface{}) *MockGrafanaMetaAccessor_SetManagedFields_Call {
|
|
return &MockGrafanaMetaAccessor_SetManagedFields_Call{Call: _e.mock.On("SetManagedFields", managedFields)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetManagedFields_Call) Run(run func(managedFields []v1.ManagedFieldsEntry)) *MockGrafanaMetaAccessor_SetManagedFields_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].([]v1.ManagedFieldsEntry))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetManagedFields_Call) Return() *MockGrafanaMetaAccessor_SetManagedFields_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetManagedFields_Call) RunAndReturn(run func([]v1.ManagedFieldsEntry)) *MockGrafanaMetaAccessor_SetManagedFields_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetManagerProperties provides a mock function with given fields: _a0
|
|
func (_m *MockGrafanaMetaAccessor) SetManagerProperties(_a0 ManagerProperties) {
|
|
_m.Called(_a0)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetManagerProperties_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetManagerProperties'
|
|
type MockGrafanaMetaAccessor_SetManagerProperties_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetManagerProperties is a helper method to define mock.On call
|
|
// - _a0 ManagerProperties
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetManagerProperties(_a0 interface{}) *MockGrafanaMetaAccessor_SetManagerProperties_Call {
|
|
return &MockGrafanaMetaAccessor_SetManagerProperties_Call{Call: _e.mock.On("SetManagerProperties", _a0)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetManagerProperties_Call) Run(run func(_a0 ManagerProperties)) *MockGrafanaMetaAccessor_SetManagerProperties_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(ManagerProperties))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetManagerProperties_Call) Return() *MockGrafanaMetaAccessor_SetManagerProperties_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetManagerProperties_Call) RunAndReturn(run func(ManagerProperties)) *MockGrafanaMetaAccessor_SetManagerProperties_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetMessage provides a mock function with given fields: msg
|
|
func (_m *MockGrafanaMetaAccessor) SetMessage(msg string) {
|
|
_m.Called(msg)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetMessage'
|
|
type MockGrafanaMetaAccessor_SetMessage_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetMessage is a helper method to define mock.On call
|
|
// - msg string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetMessage(msg interface{}) *MockGrafanaMetaAccessor_SetMessage_Call {
|
|
return &MockGrafanaMetaAccessor_SetMessage_Call{Call: _e.mock.On("SetMessage", msg)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetMessage_Call) Run(run func(msg string)) *MockGrafanaMetaAccessor_SetMessage_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetMessage_Call) Return() *MockGrafanaMetaAccessor_SetMessage_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetMessage_Call) RunAndReturn(run func(string)) *MockGrafanaMetaAccessor_SetMessage_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetName provides a mock function with given fields: name
|
|
func (_m *MockGrafanaMetaAccessor) SetName(name string) {
|
|
_m.Called(name)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetName'
|
|
type MockGrafanaMetaAccessor_SetName_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetName is a helper method to define mock.On call
|
|
// - name string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetName(name interface{}) *MockGrafanaMetaAccessor_SetName_Call {
|
|
return &MockGrafanaMetaAccessor_SetName_Call{Call: _e.mock.On("SetName", name)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetName_Call) Run(run func(name string)) *MockGrafanaMetaAccessor_SetName_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetName_Call) Return() *MockGrafanaMetaAccessor_SetName_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetName_Call) RunAndReturn(run func(string)) *MockGrafanaMetaAccessor_SetName_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetNamespace provides a mock function with given fields: namespace
|
|
func (_m *MockGrafanaMetaAccessor) SetNamespace(namespace string) {
|
|
_m.Called(namespace)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetNamespace_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetNamespace'
|
|
type MockGrafanaMetaAccessor_SetNamespace_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetNamespace is a helper method to define mock.On call
|
|
// - namespace string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetNamespace(namespace interface{}) *MockGrafanaMetaAccessor_SetNamespace_Call {
|
|
return &MockGrafanaMetaAccessor_SetNamespace_Call{Call: _e.mock.On("SetNamespace", namespace)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetNamespace_Call) Run(run func(namespace string)) *MockGrafanaMetaAccessor_SetNamespace_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetNamespace_Call) Return() *MockGrafanaMetaAccessor_SetNamespace_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetNamespace_Call) RunAndReturn(run func(string)) *MockGrafanaMetaAccessor_SetNamespace_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetOwnerReferences provides a mock function with given fields: _a0
|
|
func (_m *MockGrafanaMetaAccessor) SetOwnerReferences(_a0 []v1.OwnerReference) {
|
|
_m.Called(_a0)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetOwnerReferences_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetOwnerReferences'
|
|
type MockGrafanaMetaAccessor_SetOwnerReferences_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetOwnerReferences is a helper method to define mock.On call
|
|
// - _a0 []v1.OwnerReference
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetOwnerReferences(_a0 interface{}) *MockGrafanaMetaAccessor_SetOwnerReferences_Call {
|
|
return &MockGrafanaMetaAccessor_SetOwnerReferences_Call{Call: _e.mock.On("SetOwnerReferences", _a0)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetOwnerReferences_Call) Run(run func(_a0 []v1.OwnerReference)) *MockGrafanaMetaAccessor_SetOwnerReferences_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].([]v1.OwnerReference))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetOwnerReferences_Call) Return() *MockGrafanaMetaAccessor_SetOwnerReferences_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetOwnerReferences_Call) RunAndReturn(run func([]v1.OwnerReference)) *MockGrafanaMetaAccessor_SetOwnerReferences_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetResourceVersion provides a mock function with given fields: version
|
|
func (_m *MockGrafanaMetaAccessor) SetResourceVersion(version string) {
|
|
_m.Called(version)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetResourceVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResourceVersion'
|
|
type MockGrafanaMetaAccessor_SetResourceVersion_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetResourceVersion is a helper method to define mock.On call
|
|
// - version string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetResourceVersion(version interface{}) *MockGrafanaMetaAccessor_SetResourceVersion_Call {
|
|
return &MockGrafanaMetaAccessor_SetResourceVersion_Call{Call: _e.mock.On("SetResourceVersion", version)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetResourceVersion_Call) Run(run func(version string)) *MockGrafanaMetaAccessor_SetResourceVersion_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetResourceVersion_Call) Return() *MockGrafanaMetaAccessor_SetResourceVersion_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetResourceVersion_Call) RunAndReturn(run func(string)) *MockGrafanaMetaAccessor_SetResourceVersion_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetResourceVersionInt64 provides a mock function with given fields: _a0
|
|
func (_m *MockGrafanaMetaAccessor) SetResourceVersionInt64(_a0 int64) {
|
|
_m.Called(_a0)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetResourceVersionInt64_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetResourceVersionInt64'
|
|
type MockGrafanaMetaAccessor_SetResourceVersionInt64_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetResourceVersionInt64 is a helper method to define mock.On call
|
|
// - _a0 int64
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetResourceVersionInt64(_a0 interface{}) *MockGrafanaMetaAccessor_SetResourceVersionInt64_Call {
|
|
return &MockGrafanaMetaAccessor_SetResourceVersionInt64_Call{Call: _e.mock.On("SetResourceVersionInt64", _a0)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetResourceVersionInt64_Call) Run(run func(_a0 int64)) *MockGrafanaMetaAccessor_SetResourceVersionInt64_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetResourceVersionInt64_Call) Return() *MockGrafanaMetaAccessor_SetResourceVersionInt64_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetResourceVersionInt64_Call) RunAndReturn(run func(int64)) *MockGrafanaMetaAccessor_SetResourceVersionInt64_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetSecureValues provides a mock function with given fields: _a0
|
|
func (_m *MockGrafanaMetaAccessor) SetSecureValues(_a0 map[string]v0alpha1.InlineSecureValue) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetSecureValues")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(map[string]v0alpha1.InlineSecureValue) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetSecureValues_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSecureValues'
|
|
type MockGrafanaMetaAccessor_SetSecureValues_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetSecureValues is a helper method to define mock.On call
|
|
// - _a0 map[string]v0alpha1.InlineSecureValue
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetSecureValues(_a0 interface{}) *MockGrafanaMetaAccessor_SetSecureValues_Call {
|
|
return &MockGrafanaMetaAccessor_SetSecureValues_Call{Call: _e.mock.On("SetSecureValues", _a0)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetSecureValues_Call) Run(run func(_a0 map[string]v0alpha1.InlineSecureValue)) *MockGrafanaMetaAccessor_SetSecureValues_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(map[string]v0alpha1.InlineSecureValue))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetSecureValues_Call) Return(_a0 error) *MockGrafanaMetaAccessor_SetSecureValues_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetSecureValues_Call) RunAndReturn(run func(map[string]v0alpha1.InlineSecureValue) error) *MockGrafanaMetaAccessor_SetSecureValues_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetSelfLink provides a mock function with given fields: selfLink
|
|
func (_m *MockGrafanaMetaAccessor) SetSelfLink(selfLink string) {
|
|
_m.Called(selfLink)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetSelfLink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSelfLink'
|
|
type MockGrafanaMetaAccessor_SetSelfLink_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetSelfLink is a helper method to define mock.On call
|
|
// - selfLink string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetSelfLink(selfLink interface{}) *MockGrafanaMetaAccessor_SetSelfLink_Call {
|
|
return &MockGrafanaMetaAccessor_SetSelfLink_Call{Call: _e.mock.On("SetSelfLink", selfLink)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetSelfLink_Call) Run(run func(selfLink string)) *MockGrafanaMetaAccessor_SetSelfLink_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetSelfLink_Call) Return() *MockGrafanaMetaAccessor_SetSelfLink_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetSelfLink_Call) RunAndReturn(run func(string)) *MockGrafanaMetaAccessor_SetSelfLink_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetSourceProperties provides a mock function with given fields: _a0
|
|
func (_m *MockGrafanaMetaAccessor) SetSourceProperties(_a0 SourceProperties) {
|
|
_m.Called(_a0)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetSourceProperties_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSourceProperties'
|
|
type MockGrafanaMetaAccessor_SetSourceProperties_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetSourceProperties is a helper method to define mock.On call
|
|
// - _a0 SourceProperties
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetSourceProperties(_a0 interface{}) *MockGrafanaMetaAccessor_SetSourceProperties_Call {
|
|
return &MockGrafanaMetaAccessor_SetSourceProperties_Call{Call: _e.mock.On("SetSourceProperties", _a0)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetSourceProperties_Call) Run(run func(_a0 SourceProperties)) *MockGrafanaMetaAccessor_SetSourceProperties_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(SourceProperties))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetSourceProperties_Call) Return() *MockGrafanaMetaAccessor_SetSourceProperties_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetSourceProperties_Call) RunAndReturn(run func(SourceProperties)) *MockGrafanaMetaAccessor_SetSourceProperties_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetSpec provides a mock function with given fields: _a0
|
|
func (_m *MockGrafanaMetaAccessor) SetSpec(_a0 interface{}) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetSpec")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(interface{}) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetSpec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetSpec'
|
|
type MockGrafanaMetaAccessor_SetSpec_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetSpec is a helper method to define mock.On call
|
|
// - _a0 interface{}
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetSpec(_a0 interface{}) *MockGrafanaMetaAccessor_SetSpec_Call {
|
|
return &MockGrafanaMetaAccessor_SetSpec_Call{Call: _e.mock.On("SetSpec", _a0)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetSpec_Call) Run(run func(_a0 interface{})) *MockGrafanaMetaAccessor_SetSpec_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(interface{}))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetSpec_Call) Return(_a0 error) *MockGrafanaMetaAccessor_SetSpec_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetSpec_Call) RunAndReturn(run func(interface{}) error) *MockGrafanaMetaAccessor_SetSpec_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetStatus provides a mock function with given fields: _a0
|
|
func (_m *MockGrafanaMetaAccessor) SetStatus(_a0 interface{}) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetStatus")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(interface{}) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetStatus'
|
|
type MockGrafanaMetaAccessor_SetStatus_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetStatus is a helper method to define mock.On call
|
|
// - _a0 interface{}
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetStatus(_a0 interface{}) *MockGrafanaMetaAccessor_SetStatus_Call {
|
|
return &MockGrafanaMetaAccessor_SetStatus_Call{Call: _e.mock.On("SetStatus", _a0)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetStatus_Call) Run(run func(_a0 interface{})) *MockGrafanaMetaAccessor_SetStatus_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(interface{}))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetStatus_Call) Return(_a0 error) *MockGrafanaMetaAccessor_SetStatus_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetStatus_Call) RunAndReturn(run func(interface{}) error) *MockGrafanaMetaAccessor_SetStatus_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetUID provides a mock function with given fields: uid
|
|
func (_m *MockGrafanaMetaAccessor) SetUID(uid types.UID) {
|
|
_m.Called(uid)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUID'
|
|
type MockGrafanaMetaAccessor_SetUID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetUID is a helper method to define mock.On call
|
|
// - uid types.UID
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetUID(uid interface{}) *MockGrafanaMetaAccessor_SetUID_Call {
|
|
return &MockGrafanaMetaAccessor_SetUID_Call{Call: _e.mock.On("SetUID", uid)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetUID_Call) Run(run func(uid types.UID)) *MockGrafanaMetaAccessor_SetUID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(types.UID))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetUID_Call) Return() *MockGrafanaMetaAccessor_SetUID_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetUID_Call) RunAndReturn(run func(types.UID)) *MockGrafanaMetaAccessor_SetUID_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetUpdatedBy provides a mock function with given fields: user
|
|
func (_m *MockGrafanaMetaAccessor) SetUpdatedBy(user string) {
|
|
_m.Called(user)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetUpdatedBy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUpdatedBy'
|
|
type MockGrafanaMetaAccessor_SetUpdatedBy_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetUpdatedBy is a helper method to define mock.On call
|
|
// - user string
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetUpdatedBy(user interface{}) *MockGrafanaMetaAccessor_SetUpdatedBy_Call {
|
|
return &MockGrafanaMetaAccessor_SetUpdatedBy_Call{Call: _e.mock.On("SetUpdatedBy", user)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetUpdatedBy_Call) Run(run func(user string)) *MockGrafanaMetaAccessor_SetUpdatedBy_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetUpdatedBy_Call) Return() *MockGrafanaMetaAccessor_SetUpdatedBy_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetUpdatedBy_Call) RunAndReturn(run func(string)) *MockGrafanaMetaAccessor_SetUpdatedBy_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetUpdatedTimestamp provides a mock function with given fields: v
|
|
func (_m *MockGrafanaMetaAccessor) SetUpdatedTimestamp(v *time.Time) {
|
|
_m.Called(v)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUpdatedTimestamp'
|
|
type MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetUpdatedTimestamp is a helper method to define mock.On call
|
|
// - v *time.Time
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetUpdatedTimestamp(v interface{}) *MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call {
|
|
return &MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call{Call: _e.mock.On("SetUpdatedTimestamp", v)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call) Run(run func(v *time.Time)) *MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*time.Time))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call) Return() *MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call) RunAndReturn(run func(*time.Time)) *MockGrafanaMetaAccessor_SetUpdatedTimestamp_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SetUpdatedTimestampMillis provides a mock function with given fields: unix
|
|
func (_m *MockGrafanaMetaAccessor) SetUpdatedTimestampMillis(unix int64) {
|
|
_m.Called(unix)
|
|
}
|
|
|
|
// MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUpdatedTimestampMillis'
|
|
type MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetUpdatedTimestampMillis is a helper method to define mock.On call
|
|
// - unix int64
|
|
func (_e *MockGrafanaMetaAccessor_Expecter) SetUpdatedTimestampMillis(unix interface{}) *MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call {
|
|
return &MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call{Call: _e.mock.On("SetUpdatedTimestampMillis", unix)}
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call) Run(run func(unix int64)) *MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(int64))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call) Return() *MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call) RunAndReturn(run func(int64)) *MockGrafanaMetaAccessor_SetUpdatedTimestampMillis_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockGrafanaMetaAccessor creates a new instance of MockGrafanaMetaAccessor. 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 NewMockGrafanaMetaAccessor(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockGrafanaMetaAccessor {
|
|
mock := &MockGrafanaMetaAccessor{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|
|
|