diff --git a/pkg/apimachinery/utils/meta.go b/pkg/apimachinery/utils/meta.go index f9de7f7b0a0..2907897851b 100644 --- a/pkg/apimachinery/utils/meta.go +++ b/pkg/apimachinery/utils/meta.go @@ -76,6 +76,8 @@ const AnnoKeyFullpathUIDs = "grafana.app/fullpathUIDs" const LabelKeyDeprecatedInternalID = "grafana.app/deprecatedInternalID" // Accessor functions for k8s objects +// +//go:generate mockery --name GrafanaMetaAccessor --structname MockGrafanaMetaAccessor --inpackage --filename meta_mock.go --with-expecter type GrafanaMetaAccessor interface { metav1.Object diff --git a/pkg/apimachinery/utils/meta_mock.go b/pkg/apimachinery/utils/meta_mock.go new file mode 100644 index 00000000000..d73107b1bd6 --- /dev/null +++ b/pkg/apimachinery/utils/meta_mock.go @@ -0,0 +1,2674 @@ +// Code generated by mockery v2.52.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" + + 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 +} + +// 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 +} + +// 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 +} diff --git a/pkg/registry/apis/provisioning/jobs/export/all.go b/pkg/registry/apis/provisioning/jobs/export/all.go index 3824dae0331..2f4b2253f76 100644 --- a/pkg/registry/apis/provisioning/jobs/export/all.go +++ b/pkg/registry/apis/provisioning/jobs/export/all.go @@ -10,6 +10,7 @@ import ( ) func ExportAll(ctx context.Context, repoName string, options provisioning.ExportJobOptions, clients resources.ResourceClients, repositoryResources resources.RepositoryResources, folderClient dynamic.ResourceInterface, progress jobs.JobProgressRecorder) error { + // FIXME: should we sign with grafana user? if err := ExportFolders(ctx, repoName, options, folderClient, repositoryResources, progress); err != nil { return err } diff --git a/pkg/registry/apis/provisioning/jobs/export/worker.go b/pkg/registry/apis/provisioning/jobs/export/worker.go index 4d5305cf58c..73e4eaa6c2e 100644 --- a/pkg/registry/apis/provisioning/jobs/export/worker.go +++ b/pkg/registry/apis/provisioning/jobs/export/worker.go @@ -97,7 +97,7 @@ func (r *ExportWorker) Process(ctx context.Context, repo repository.Repository, return errors.New("export job submitted targeting repository that is not a ReaderWriter") } - repositoryResources, err := r.repositoryResources.Client(ctx, rw, resources.RepositoryResourcesOptions{}) + repositoryResources, err := r.repositoryResources.Client(ctx, rw) if err != nil { return fmt.Errorf("create repository resource client: %w", err) } diff --git a/pkg/registry/apis/provisioning/jobs/export/worker_test.go b/pkg/registry/apis/provisioning/jobs/export/worker_test.go index 58f37b12b5b..3e56f63047f 100644 --- a/pkg/registry/apis/provisioning/jobs/export/worker_test.go +++ b/pkg/registry/apis/provisioning/jobs/export/worker_test.go @@ -249,7 +249,7 @@ func TestExportWorker_ProcessRepositoryResourcesError(t *testing.T) { mockClients.On("Clients", context.Background(), "test-namespace").Return(resourceClients, nil) mockRepoResources := resources.NewMockRepositoryResourcesFactory(t) - mockRepoResources.On("Client", context.Background(), mockRepo, resources.RepositoryResourcesOptions{}).Return(nil, fmt.Errorf("failed to create repository resources client")) + mockRepoResources.On("Client", context.Background(), mockRepo).Return(nil, fmt.Errorf("failed to create repository resources client")) mockProgress := jobs.NewMockJobProgressRecorder(t) mockCloneFn := NewMockWrapWithCloneFn(t) @@ -292,7 +292,7 @@ func TestExportWorker_ProcessCloneAndPushOptions(t *testing.T) { mockRepoResources := resources.NewMockRepositoryResourcesFactory(t) mockRepoResourcesClient := resources.NewMockRepositoryResources(t) - mockRepoResources.On("Client", mock.Anything, mock.Anything, resources.RepositoryResourcesOptions{}).Return(mockRepoResourcesClient, nil) + mockRepoResources.On("Client", mock.Anything, mock.Anything).Return(mockRepoResourcesClient, nil) mockExportFn := NewMockExportFn(t) mockExportFn.On("Execute", mock.Anything, "test-repo", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) @@ -343,7 +343,7 @@ func TestExportWorker_ProcessExportFnError(t *testing.T) { mockRepoResources := resources.NewMockRepositoryResourcesFactory(t) mockRepoResourcesClient := resources.NewMockRepositoryResources(t) - mockRepoResources.On("Client", mock.Anything, mock.Anything, resources.RepositoryResourcesOptions{}).Return(mockRepoResourcesClient, nil) + mockRepoResources.On("Client", mock.Anything, mock.Anything).Return(mockRepoResourcesClient, nil) mockExportFn := NewMockExportFn(t) mockExportFn.On("Execute", mock.Anything, "test-repo", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New("export failed")) diff --git a/pkg/registry/apis/provisioning/jobs/migrate/folders.go b/pkg/registry/apis/provisioning/jobs/migrate/folders.go index d6b4e0f4b6b..68b89360483 100644 --- a/pkg/registry/apis/provisioning/jobs/migrate/folders.go +++ b/pkg/registry/apis/provisioning/jobs/migrate/folders.go @@ -74,6 +74,7 @@ func (f *legacyFoldersMigrator) Migrate(ctx context.Context, namespace string, r } progress.SetMessage(ctx, "export folders from SQL") + // FIXME: we don't sign folders, not even with grafana user if err := repositoryResources.EnsureFolderTreeExists(ctx, "", "", f.tree, func(folder resources.Folder, created bool, err error) error { result := jobs.JobResourceResult{ Action: repository.FileActionCreated, diff --git a/pkg/registry/apis/provisioning/jobs/migrate/resources.go b/pkg/registry/apis/provisioning/jobs/migrate/resources.go index 6b2ea146834..43cb3375f77 100644 --- a/pkg/registry/apis/provisioning/jobs/migrate/resources.go +++ b/pkg/registry/apis/provisioning/jobs/migrate/resources.go @@ -12,6 +12,7 @@ import ( "github.com/grafana/grafana/pkg/registry/apis/provisioning/jobs" "github.com/grafana/grafana/pkg/registry/apis/provisioning/repository" "github.com/grafana/grafana/pkg/registry/apis/provisioning/resources" + "github.com/grafana/grafana/pkg/registry/apis/provisioning/resources/signature" "github.com/grafana/grafana/pkg/storage/unified/parquet" "github.com/grafana/grafana/pkg/storage/unified/resource" ) @@ -28,6 +29,7 @@ type legacyResourcesMigrator struct { parsers resources.ParserFactory legacyMigrator legacy.LegacyMigrator folderMigrator LegacyFoldersMigrator + signerFactory signature.SignerFactory } func NewLegacyResourcesMigrator( @@ -35,12 +37,14 @@ func NewLegacyResourcesMigrator( parsers resources.ParserFactory, legacyMigrator legacy.LegacyMigrator, folderMigrator LegacyFoldersMigrator, + signerFactory signature.SignerFactory, ) LegacyResourcesMigrator { return &legacyResourcesMigrator{ repositoryResources: repositoryResources, parsers: parsers, legacyMigrator: legacyMigrator, folderMigrator: folderMigrator, + signerFactory: signerFactory, } } @@ -50,15 +54,21 @@ func (m *legacyResourcesMigrator) Migrate(ctx context.Context, rw repository.Rea return fmt.Errorf("get parser: %w", err) } - repoOpts := resources.RepositoryResourcesOptions{ - PreloadAllUserInfo: opts.History, - } - - repositoryResources, err := m.repositoryResources.Client(ctx, rw, repoOpts) + repositoryResources, err := m.repositoryResources.Client(ctx, rw) if err != nil { return fmt.Errorf("get repository resources: %w", err) } + // FIXME: signature is only relevant for repositories which support signature + // Not all repositories support history + signer, err := m.signerFactory.New(ctx, signature.SignOptions{ + Namespace: namespace, + History: opts.History, + }) + if err != nil { + return fmt.Errorf("get signer: %w", err) + } + progress.SetMessage(ctx, "migrate folders from SQL") if err := m.folderMigrator.Migrate(ctx, namespace, repositoryResources, progress); err != nil { return fmt.Errorf("migrate folders from SQL: %w", err) @@ -70,7 +80,17 @@ func (m *legacyResourcesMigrator) Migrate(ctx context.Context, rw repository.Rea continue } - reader := NewLegacyResourceMigrator(m.legacyMigrator, parser, repositoryResources, progress, opts, namespace, kind.GroupResource()) + reader := NewLegacyResourceMigrator( + m.legacyMigrator, + parser, + repositoryResources, + progress, + opts, + namespace, + kind.GroupResource(), + signer, + ) + if err := reader.Migrate(ctx); err != nil { return fmt.Errorf("migrate resource %s: %w", kind, err) } @@ -87,9 +107,19 @@ type legacyResourceResourceMigrator struct { kind schema.GroupResource options provisioning.MigrateJobOptions resources resources.RepositoryResources + signer signature.Signer } -func NewLegacyResourceMigrator(legacy legacy.LegacyMigrator, parser resources.Parser, resources resources.RepositoryResources, progress jobs.JobProgressRecorder, options provisioning.MigrateJobOptions, namespace string, kind schema.GroupResource) *legacyResourceResourceMigrator { +func NewLegacyResourceMigrator( + legacy legacy.LegacyMigrator, + parser resources.Parser, + resources resources.RepositoryResources, + progress jobs.JobProgressRecorder, + options provisioning.MigrateJobOptions, + namespace string, + kind schema.GroupResource, + signer signature.Signer, +) *legacyResourceResourceMigrator { return &legacyResourceResourceMigrator{ legacy: legacy, parser: parser, @@ -98,6 +128,7 @@ func NewLegacyResourceMigrator(legacy legacy.LegacyMigrator, parser resources.Pa namespace: namespace, kind: kind, resources: resources, + signer: signer, } } @@ -126,6 +157,12 @@ func (r *legacyResourceResourceMigrator) Write(ctx context.Context, key *resourc parsed.Meta.SetManagerProperties(utils.ManagerProperties{}) parsed.Meta.SetSourceProperties(utils.SourceProperties{}) + // Add author signature to the context + ctx, err = r.signer.Sign(ctx, parsed.Meta) + if err != nil { + return fmt.Errorf("add author signature: %w", err) + } + // TODO: this seems to be same logic as the export job // TODO: we should use a kind safe manager here fileName, err := r.resources.CreateResourceFileFromObject(ctx, parsed.Obj, resources.WriteOptions{ diff --git a/pkg/registry/apis/provisioning/jobs/migrate/resources_test.go b/pkg/registry/apis/provisioning/jobs/migrate/resources_test.go index 58f4feab205..e48c2567575 100644 --- a/pkg/registry/apis/provisioning/jobs/migrate/resources_test.go +++ b/pkg/registry/apis/provisioning/jobs/migrate/resources_test.go @@ -3,6 +3,7 @@ package migrate import ( "context" "errors" + "fmt" "testing" "github.com/stretchr/testify/assert" @@ -17,6 +18,7 @@ import ( "github.com/grafana/grafana/pkg/registry/apis/provisioning/jobs" "github.com/grafana/grafana/pkg/registry/apis/provisioning/repository" "github.com/grafana/grafana/pkg/registry/apis/provisioning/resources" + "github.com/grafana/grafana/pkg/registry/apis/provisioning/resources/signature" "github.com/grafana/grafana/pkg/storage/unified/resource" ) @@ -26,11 +28,14 @@ func TestLegacyResourcesMigrator_Migrate(t *testing.T) { mockParserFactory.On("GetParser", mock.Anything, mock.Anything). Return(nil, errors.New("parser factory error")) + signerFactory := signature.NewMockSignerFactory(t) + migrator := NewLegacyResourcesMigrator( nil, mockParserFactory, nil, nil, + signerFactory, ) err := migrator.Migrate(context.Background(), nil, "test-namespace", provisioning.MigrateJobOptions{}, jobs.NewMockJobProgressRecorder(t)) @@ -48,12 +53,14 @@ func TestLegacyResourcesMigrator_Migrate(t *testing.T) { mockRepoResourcesFactory := resources.NewMockRepositoryResourcesFactory(t) mockRepoResourcesFactory.On("Client", mock.Anything, mock.Anything, mock.Anything). Return(nil, errors.New("repo resources factory error")) + signerFactory := signature.NewMockSignerFactory(t) migrator := NewLegacyResourcesMigrator( mockRepoResourcesFactory, mockParserFactory, nil, nil, + signerFactory, ) err := migrator.Migrate(context.Background(), nil, "test-namespace", provisioning.MigrateJobOptions{}, jobs.NewMockJobProgressRecorder(t)) @@ -81,11 +88,17 @@ func TestLegacyResourcesMigrator_Migrate(t *testing.T) { progress := jobs.NewMockJobProgressRecorder(t) progress.On("SetMessage", mock.Anything, mock.Anything).Return() + signer := signature.NewMockSigner(t) + signerFactory := signature.NewMockSignerFactory(t) + signerFactory.On("New", mock.Anything, mock.Anything). + Return(signer, nil) + migrator := NewLegacyResourcesMigrator( mockRepoResourcesFactory, mockParserFactory, nil, mockFolderMigrator, + signerFactory, ) err := migrator.Migrate(context.Background(), nil, "test-namespace", provisioning.MigrateJobOptions{}, progress) @@ -120,11 +133,17 @@ func TestLegacyResourcesMigrator_Migrate(t *testing.T) { progress := jobs.NewMockJobProgressRecorder(t) progress.On("SetMessage", mock.Anything, mock.Anything).Return() + signer := signature.NewMockSigner(t) + signerFactory := signature.NewMockSignerFactory(t) + signerFactory.On("New", mock.Anything, mock.Anything). + Return(signer, nil) + migrator := NewLegacyResourcesMigrator( mockRepoResourcesFactory, mockParserFactory, mockLegacyMigrator, mockFolderMigrator, + signerFactory, ) err := migrator.Migrate(context.Background(), nil, "test-namespace", provisioning.MigrateJobOptions{}, progress) @@ -138,6 +157,45 @@ func TestLegacyResourcesMigrator_Migrate(t *testing.T) { progress.AssertExpectations(t) }) + t.Run("should fail when signer factory fails", func(t *testing.T) { + mockParserFactory := resources.NewMockParserFactory(t) + mockParserFactory.On("GetParser", mock.Anything, mock.Anything). + Return(resources.NewMockParser(t), nil) + + mockRepoResources := resources.NewMockRepositoryResources(t) + mockRepoResourcesFactory := resources.NewMockRepositoryResourcesFactory(t) + mockRepoResourcesFactory.On("Client", mock.Anything, mock.Anything, mock.Anything). + Return(mockRepoResources, nil) + + mockFolderMigrator := NewMockLegacyFoldersMigrator(t) + mockSignerFactory := signature.NewMockSignerFactory(t) + mockSignerFactory.On("New", mock.Anything, signature.SignOptions{ + Namespace: "test-namespace", + History: true, + }).Return(nil, fmt.Errorf("signer factory error")) + + progress := jobs.NewMockJobProgressRecorder(t) + migrator := NewLegacyResourcesMigrator( + mockRepoResourcesFactory, + mockParserFactory, + nil, + mockFolderMigrator, + mockSignerFactory, + ) + + err := migrator.Migrate(context.Background(), nil, "test-namespace", provisioning.MigrateJobOptions{ + History: true, + }, progress) + require.Error(t, err) + require.EqualError(t, err, "get signer: signer factory error") + + mockParserFactory.AssertExpectations(t) + mockRepoResourcesFactory.AssertExpectations(t) + mockFolderMigrator.AssertExpectations(t) + mockSignerFactory.AssertExpectations(t) + progress.AssertExpectations(t) + }) + t.Run("should successfully migrate all resources", func(t *testing.T) { mockParser := resources.NewMockParser(t) mockParserFactory := resources.NewMockParserFactory(t) @@ -153,6 +211,13 @@ func TestLegacyResourcesMigrator_Migrate(t *testing.T) { mockFolderMigrator.On("Migrate", mock.Anything, "test-namespace", mockRepoResources, mock.Anything). Return(nil) + mockSigner := signature.NewMockSigner(t) + mockSignerFactory := signature.NewMockSignerFactory(t) + mockSignerFactory.On("New", mock.Anything, signature.SignOptions{ + Namespace: "test-namespace", + History: true, + }).Return(mockSigner, nil) + mockLegacyMigrator := legacy.NewMockLegacyMigrator(t) mockLegacyMigrator.On("Migrate", mock.Anything, mock.MatchedBy(func(opts legacy.MigrateOptions) bool { return opts.OnlyCount && opts.Namespace == "test-namespace" @@ -180,9 +245,12 @@ func TestLegacyResourcesMigrator_Migrate(t *testing.T) { mockParserFactory, mockLegacyMigrator, mockFolderMigrator, + mockSignerFactory, ) - err := migrator.Migrate(context.Background(), nil, "test-namespace", provisioning.MigrateJobOptions{}, progress) + err := migrator.Migrate(context.Background(), nil, "test-namespace", provisioning.MigrateJobOptions{ + History: true, + }, progress) require.NoError(t, err) mockParserFactory.AssertExpectations(t) @@ -209,6 +277,7 @@ func TestLegacyResourceResourceMigrator_Write(t *testing.T) { provisioning.MigrateJobOptions{}, "test-namespace", schema.GroupResource{Group: "test.grafana.app", Resource: "tests"}, + signature.NewGrafanaSigner(), ) err := migrator.Write(context.Background(), &resource.ResourceKey{}, []byte("test")) @@ -257,6 +326,7 @@ func TestLegacyResourceResourceMigrator_Write(t *testing.T) { provisioning.MigrateJobOptions{}, "test-namespace", schema.GroupResource{Group: "test.grafana.app", Resource: "tests"}, + signature.NewGrafanaSigner(), ) err = migrator.Write(context.Background(), &resource.ResourceKey{}, []byte("test")) @@ -267,6 +337,108 @@ func TestLegacyResourceResourceMigrator_Write(t *testing.T) { progress.AssertExpectations(t) }) + t.Run("should fail when signer fails", func(t *testing.T) { + mockParser := resources.NewMockParser(t) + obj := &unstructured.Unstructured{ + Object: map[string]interface{}{ + "metadata": map[string]interface{}{ + "name": "test", + }, + }, + } + meta, err := utils.MetaAccessor(obj) + require.NoError(t, err) + + mockParser.On("Parse", mock.Anything, mock.Anything). + Return(&resources.ParsedResource{ + Meta: meta, + Obj: obj, + }, nil) + + mockSigner := signature.NewMockSigner(t) + mockSigner.On("Sign", mock.Anything, meta). + Return(nil, errors.New("signing error")) + + progress := jobs.NewMockJobProgressRecorder(t) + migrator := NewLegacyResourceMigrator( + nil, + mockParser, + nil, + progress, + provisioning.MigrateJobOptions{}, + "test-namespace", + schema.GroupResource{Group: "test.grafana.app", Resource: "tests"}, + mockSigner, + ) + + err = migrator.Write(context.Background(), &resource.ResourceKey{}, []byte("test")) + require.Error(t, err) + require.EqualError(t, err, "add author signature: signing error") + + mockParser.AssertExpectations(t) + mockSigner.AssertExpectations(t) + progress.AssertExpectations(t) + }) + + t.Run("should successfully add author signature", func(t *testing.T) { + mockParser := resources.NewMockParser(t) + obj := &unstructured.Unstructured{ + Object: map[string]interface{}{ + "metadata": map[string]interface{}{ + "name": "test", + }, + }, + } + meta, err := utils.MetaAccessor(obj) + require.NoError(t, err) + + mockParser.On("Parse", mock.Anything, mock.Anything). + Return(&resources.ParsedResource{ + Meta: meta, + Obj: obj, + }, nil) + + mockSigner := signature.NewMockSigner(t) + signedCtx := repository.WithAuthorSignature(context.Background(), repository.CommitSignature{ + Name: "test-user", + Email: "test@example.com", + }) + mockSigner.On("Sign", mock.Anything, meta). + Return(signedCtx, nil) + + mockRepoResources := resources.NewMockRepositoryResources(t) + mockRepoResources.On("CreateResourceFileFromObject", signedCtx, mock.Anything, mock.Anything). + Return("test/path", nil) + + progress := jobs.NewMockJobProgressRecorder(t) + progress.On("Record", mock.Anything, mock.MatchedBy(func(result jobs.JobResourceResult) bool { + return result.Action == repository.FileActionCreated && + result.Name == "test" && + result.Error == nil && + result.Path == "test/path" + })).Return() + progress.On("TooManyErrors").Return(nil) + + migrator := NewLegacyResourceMigrator( + nil, + mockParser, + mockRepoResources, + progress, + provisioning.MigrateJobOptions{}, + "test-namespace", + schema.GroupResource{Group: "test.grafana.app", Resource: "tests"}, + mockSigner, + ) + + err = migrator.Write(context.Background(), &resource.ResourceKey{}, []byte("test")) + require.NoError(t, err) + + mockParser.AssertExpectations(t) + mockSigner.AssertExpectations(t) + mockRepoResources.AssertExpectations(t) + progress.AssertExpectations(t) + }) + t.Run("should successfully write resource", func(t *testing.T) { mockParser := resources.NewMockParser(t) obj := &unstructured.Unstructured{ @@ -338,6 +510,7 @@ func TestLegacyResourceResourceMigrator_Write(t *testing.T) { provisioning.MigrateJobOptions{}, "test-namespace", schema.GroupResource{Group: "test.grafana.app", Resource: "tests"}, + signature.NewGrafanaSigner(), ) err = migrator.Write(context.Background(), &resource.ResourceKey{}, []byte("test")) @@ -382,6 +555,7 @@ func TestLegacyResourceResourceMigrator_Write(t *testing.T) { provisioning.MigrateJobOptions{}, "test-namespace", schema.GroupResource{Group: "test.grafana.app", Resource: "tests"}, + signature.NewGrafanaSigner(), ) err = migrator.Write(context.Background(), &resource.ResourceKey{}, []byte("test")) @@ -411,6 +585,7 @@ func TestLegacyResourceResourceMigrator_Migrate(t *testing.T) { provisioning.MigrateJobOptions{}, "test-namespace", schema.GroupResource{Group: "test.grafana.app", Resource: "tests"}, + signature.NewGrafanaSigner(), ) err := migrator.Migrate(context.Background()) @@ -441,6 +616,7 @@ func TestLegacyResourceResourceMigrator_Migrate(t *testing.T) { provisioning.MigrateJobOptions{}, "test-namespace", schema.GroupResource{Group: "test.grafana.app", Resource: "test-resources"}, + signature.NewGrafanaSigner(), ) err := migrator.Migrate(context.Background()) @@ -471,6 +647,7 @@ func TestLegacyResourceResourceMigrator_Migrate(t *testing.T) { provisioning.MigrateJobOptions{}, "test-namespace", schema.GroupResource{Group: "test.grafana.app", Resource: "tests"}, + signature.NewGrafanaSigner(), ) err := migrator.Migrate(context.Background()) @@ -509,6 +686,7 @@ func TestLegacyResourceResourceMigrator_Migrate(t *testing.T) { provisioning.MigrateJobOptions{}, "test-namespace", schema.GroupResource{Group: "test.grafana.app", Resource: "tests"}, + signature.NewGrafanaSigner(), ) err := migrator.Migrate(context.Background()) @@ -538,6 +716,7 @@ func TestLegacyResourceResourceMigrator_Migrate(t *testing.T) { progress := jobs.NewMockJobProgressRecorder(t) progress.On("SetMessage", mock.Anything, mock.Anything).Return() progress.On("SetTotal", mock.Anything, 200).Return() + signer := signature.NewMockSigner(t) migrator := NewLegacyResourceMigrator( mockLegacyMigrator, @@ -547,6 +726,7 @@ func TestLegacyResourceResourceMigrator_Migrate(t *testing.T) { provisioning.MigrateJobOptions{}, "test-namespace", schema.GroupResource{Group: "test.grafana.app", Resource: "tests"}, + signer, ) err := migrator.Migrate(context.Background()) diff --git a/pkg/registry/apis/provisioning/jobs/sync/worker.go b/pkg/registry/apis/provisioning/jobs/sync/worker.go index cb2ca26368a..d68b17c60ee 100644 --- a/pkg/registry/apis/provisioning/jobs/sync/worker.go +++ b/pkg/registry/apis/provisioning/jobs/sync/worker.go @@ -86,7 +86,7 @@ func (r *SyncWorker) Process(ctx context.Context, repo repository.Repository, jo return fmt.Errorf("update repo with job status at start: %w", err) } - repositoryResources, err := r.repositoryResources.Client(ctx, rw, resources.RepositoryResourcesOptions{}) + repositoryResources, err := r.repositoryResources.Client(ctx, rw) if err != nil { return fmt.Errorf("create repository resources client: %w", err) } diff --git a/pkg/registry/apis/provisioning/jobs/sync/worker_test.go b/pkg/registry/apis/provisioning/jobs/sync/worker_test.go index 1bf3d25d0b1..f351173467e 100644 --- a/pkg/registry/apis/provisioning/jobs/sync/worker_test.go +++ b/pkg/registry/apis/provisioning/jobs/sync/worker_test.go @@ -157,7 +157,7 @@ func TestSyncWorker_Process(t *testing.T) { rpf.On("Execute", mock.Anything, repoConfig, mock.Anything).Return(nil) // Repository resources creation fails - rrf.On("Client", mock.Anything, mock.Anything, resources.RepositoryResourcesOptions{}).Return(nil, errors.New("failed to create repository resources client")) + rrf.On("Client", mock.Anything, mock.Anything).Return(nil, errors.New("failed to create repository resources client")) }, expectedError: "create repository resources client: failed to create repository resources client", }, @@ -189,7 +189,7 @@ func TestSyncWorker_Process(t *testing.T) { rpf.On("Execute", mock.Anything, repoConfig, mock.Anything).Return(nil) // Repository resources creation succeeds - rrf.On("Client", mock.Anything, mock.Anything, resources.RepositoryResourcesOptions{}).Return(&resources.MockRepositoryResources{}, nil) + rrf.On("Client", mock.Anything, mock.Anything).Return(&resources.MockRepositoryResources{}, nil) // Getting clients for namespace fails cf.On("Clients", mock.Anything, "test-namespace").Return(nil, errors.New("failed to get clients")) @@ -222,7 +222,7 @@ func TestSyncWorker_Process(t *testing.T) { // Setup resources and clients mockRepoResources := resources.NewMockRepositoryResources(t) mockRepoResources.On("Stats", mock.Anything).Return(nil, nil) - rrf.On("Client", mock.Anything, mock.Anything, resources.RepositoryResourcesOptions{}).Return(mockRepoResources, nil) + rrf.On("Client", mock.Anything, mock.Anything).Return(mockRepoResources, nil) mockClients := resources.NewMockResourceClients(t) cf.On("Clients", mock.Anything, "test-namespace").Return(mockClients, nil) @@ -277,7 +277,7 @@ func TestSyncWorker_Process(t *testing.T) { // Setup resources and clients mockRepoResources := resources.NewMockRepositoryResources(t) mockRepoResources.On("Stats", mock.Anything).Return(nil, nil) - rrf.On("Client", mock.Anything, mock.Anything, resources.RepositoryResourcesOptions{}).Return(mockRepoResources, nil) + rrf.On("Client", mock.Anything, mock.Anything).Return(mockRepoResources, nil) mockClients := resources.NewMockResourceClients(t) cf.On("Clients", mock.Anything, "test-namespace").Return(mockClients, nil) @@ -321,7 +321,7 @@ func TestSyncWorker_Process(t *testing.T) { mockRepoResources := resources.NewMockRepositoryResources(t) mockRepoResources.On("Stats", mock.Anything).Return(nil, errors.New("stats error")) - rrf.On("Client", mock.Anything, mock.Anything, resources.RepositoryResourcesOptions{}).Return(mockRepoResources, nil) + rrf.On("Client", mock.Anything, mock.Anything).Return(mockRepoResources, nil) // Simple mocks for other calls mockClients := resources.NewMockResourceClients(t) @@ -347,7 +347,7 @@ func TestSyncWorker_Process(t *testing.T) { mockRepoResources := resources.NewMockRepositoryResources(t) mockRepoResources.On("Stats", mock.Anything).Return(nil, nil) - rrf.On("Client", mock.Anything, mock.Anything, resources.RepositoryResourcesOptions{}).Return(mockRepoResources, nil) + rrf.On("Client", mock.Anything, mock.Anything).Return(mockRepoResources, nil) // Verify only sync status is patched rpf.On("Execute", mock.Anything, mock.Anything, mock.MatchedBy(func(patch []map[string]interface{}) bool { @@ -391,7 +391,7 @@ func TestSyncWorker_Process(t *testing.T) { }, } mockRepoResources.On("Stats", mock.Anything).Return(stats, nil) - rrf.On("Client", mock.Anything, mock.Anything, resources.RepositoryResourcesOptions{}).Return(mockRepoResources, nil) + rrf.On("Client", mock.Anything, mock.Anything).Return(mockRepoResources, nil) // Verify both sync status and stats are patched rpf.On("Execute", mock.Anything, mock.Anything, mock.MatchedBy(func(patch []map[string]interface{}) bool { @@ -463,7 +463,7 @@ func TestSyncWorker_Process(t *testing.T) { }, } mockRepoResources.On("Stats", mock.Anything).Return(stats, nil) - rrf.On("Client", mock.Anything, mock.Anything, resources.RepositoryResourcesOptions{}).Return(mockRepoResources, nil) + rrf.On("Client", mock.Anything, mock.Anything).Return(mockRepoResources, nil) // Verify only sync status is patched (multiple stats should be ignored) rpf.On("Execute", mock.Anything, mock.Anything, mock.MatchedBy(func(patch []map[string]interface{}) bool { @@ -497,7 +497,7 @@ func TestSyncWorker_Process(t *testing.T) { // Setup resources and clients mockRepoResources := resources.NewMockRepositoryResources(t) mockRepoResources.On("Stats", mock.Anything).Return(nil, nil) - rrf.On("Client", mock.Anything, mock.Anything, resources.RepositoryResourcesOptions{}).Return(mockRepoResources, nil) + rrf.On("Client", mock.Anything, mock.Anything).Return(mockRepoResources, nil) mockClients := resources.NewMockResourceClients(t) cf.On("Clients", mock.Anything, mock.Anything).Return(mockClients, nil) diff --git a/pkg/registry/apis/provisioning/register.go b/pkg/registry/apis/provisioning/register.go index 024a828f88f..bccff626351 100644 --- a/pkg/registry/apis/provisioning/register.go +++ b/pkg/registry/apis/provisioning/register.go @@ -49,6 +49,7 @@ import ( "github.com/grafana/grafana/pkg/registry/apis/provisioning/repository/github" gogit "github.com/grafana/grafana/pkg/registry/apis/provisioning/repository/go-git" "github.com/grafana/grafana/pkg/registry/apis/provisioning/resources" + "github.com/grafana/grafana/pkg/registry/apis/provisioning/resources/signature" "github.com/grafana/grafana/pkg/registry/apis/provisioning/safepath" "github.com/grafana/grafana/pkg/registry/apis/provisioning/secrets" "github.com/grafana/grafana/pkg/services/apiserver" @@ -546,13 +547,14 @@ func (b *APIBuilder) GetPostStartHooks() (map[string]genericapiserver.PostStartH statusPatcher.Patch, syncer, ) - + signerFactory := signature.NewSignerFactory(b.clients) legacyFolders := migrate.NewLegacyFoldersMigrator(b.legacyMigrator) legacyResources := migrate.NewLegacyResourcesMigrator( b.repositoryResources, b.parsers, b.legacyMigrator, legacyFolders, + signerFactory, ) storageSwapper := migrate.NewStorageSwapper(b.unified, b.storageStatus) legacyMigrator := migrate.NewLegacyMigrator( diff --git a/pkg/registry/apis/provisioning/resources/repository.go b/pkg/registry/apis/provisioning/resources/repository.go index 011bd409bf0..87957f78023 100644 --- a/pkg/registry/apis/provisioning/resources/repository.go +++ b/pkg/registry/apis/provisioning/resources/repository.go @@ -10,15 +10,9 @@ import ( "k8s.io/apimachinery/pkg/runtime/schema" ) -type RepositoryResourcesOptions struct { - // FIXME: this is a temporary option to preload all user info - // we should remove this once we have a better way to handle user info and commit signatures - PreloadAllUserInfo bool -} - //go:generate mockery --name RepositoryResourcesFactory --structname MockRepositoryResourcesFactory --inpackage --filename repository_resources_factory_mock.go --with-expecter type RepositoryResourcesFactory interface { - Client(ctx context.Context, repo repository.ReaderWriter, opts RepositoryResourcesOptions) (RepositoryResources, error) + Client(ctx context.Context, repo repository.ReaderWriter) (RepositoryResources, error) } //go:generate mockery --name RepositoryResources --structname MockRepositoryResources --inpackage --filename repository_resources_mock.go --with-expecter @@ -64,7 +58,7 @@ func NewRepositoryResourcesFactory(parsers ParserFactory, clients ClientFactory, return &repositoryResourcesFactory{parsers, clients, lister} } -func (r *repositoryResourcesFactory) Client(ctx context.Context, repo repository.ReaderWriter, opts RepositoryResourcesOptions) (RepositoryResources, error) { +func (r *repositoryResourcesFactory) Client(ctx context.Context, repo repository.ReaderWriter) (RepositoryResources, error) { clients, err := r.clients.Clients(ctx, repo.Config().Namespace) if err != nil { return nil, fmt.Errorf("create clients: %w", err) @@ -79,21 +73,8 @@ func (r *repositoryResourcesFactory) Client(ctx context.Context, repo repository return nil, fmt.Errorf("create parser: %w", err) } - signatures := map[string]repository.CommitSignature{} - if opts.PreloadAllUserInfo { - userClient, err := clients.User() - if err != nil { - return nil, fmt.Errorf("create user client: %w", err) - } - - signatures, err = loadUsers(ctx, userClient) - if err != nil { - return nil, fmt.Errorf("load users: %w", err) - } - } - folders := NewFolderManager(repo, folderClient, NewEmptyFolderTree()) - resources := NewResourcesManager(repo, folders, parser, clients, signatures) + resources := NewResourcesManager(repo, folders, parser, clients) return &repositoryResources{ FolderManager: folders, diff --git a/pkg/registry/apis/provisioning/resources/repository_resources_factory_mock.go b/pkg/registry/apis/provisioning/resources/repository_resources_factory_mock.go index c6062f02093..3e55762e261 100644 --- a/pkg/registry/apis/provisioning/resources/repository_resources_factory_mock.go +++ b/pkg/registry/apis/provisioning/resources/repository_resources_factory_mock.go @@ -22,9 +22,9 @@ func (_m *MockRepositoryResourcesFactory) EXPECT() *MockRepositoryResourcesFacto return &MockRepositoryResourcesFactory_Expecter{mock: &_m.Mock} } -// Client provides a mock function with given fields: ctx, repo, opts -func (_m *MockRepositoryResourcesFactory) Client(ctx context.Context, repo repository.ReaderWriter, opts RepositoryResourcesOptions) (RepositoryResources, error) { - ret := _m.Called(ctx, repo, opts) +// Client provides a mock function with given fields: ctx, repo +func (_m *MockRepositoryResourcesFactory) Client(ctx context.Context, repo repository.ReaderWriter) (RepositoryResources, error) { + ret := _m.Called(ctx, repo) if len(ret) == 0 { panic("no return value specified for Client") @@ -32,19 +32,19 @@ func (_m *MockRepositoryResourcesFactory) Client(ctx context.Context, repo repos var r0 RepositoryResources var r1 error - if rf, ok := ret.Get(0).(func(context.Context, repository.ReaderWriter, RepositoryResourcesOptions) (RepositoryResources, error)); ok { - return rf(ctx, repo, opts) + if rf, ok := ret.Get(0).(func(context.Context, repository.ReaderWriter) (RepositoryResources, error)); ok { + return rf(ctx, repo) } - if rf, ok := ret.Get(0).(func(context.Context, repository.ReaderWriter, RepositoryResourcesOptions) RepositoryResources); ok { - r0 = rf(ctx, repo, opts) + if rf, ok := ret.Get(0).(func(context.Context, repository.ReaderWriter) RepositoryResources); ok { + r0 = rf(ctx, repo) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(RepositoryResources) } } - if rf, ok := ret.Get(1).(func(context.Context, repository.ReaderWriter, RepositoryResourcesOptions) error); ok { - r1 = rf(ctx, repo, opts) + if rf, ok := ret.Get(1).(func(context.Context, repository.ReaderWriter) error); ok { + r1 = rf(ctx, repo) } else { r1 = ret.Error(1) } @@ -60,14 +60,13 @@ type MockRepositoryResourcesFactory_Client_Call struct { // Client is a helper method to define mock.On call // - ctx context.Context // - repo repository.ReaderWriter -// - opts RepositoryResourcesOptions -func (_e *MockRepositoryResourcesFactory_Expecter) Client(ctx interface{}, repo interface{}, opts interface{}) *MockRepositoryResourcesFactory_Client_Call { - return &MockRepositoryResourcesFactory_Client_Call{Call: _e.mock.On("Client", ctx, repo, opts)} +func (_e *MockRepositoryResourcesFactory_Expecter) Client(ctx interface{}, repo interface{}) *MockRepositoryResourcesFactory_Client_Call { + return &MockRepositoryResourcesFactory_Client_Call{Call: _e.mock.On("Client", ctx, repo)} } -func (_c *MockRepositoryResourcesFactory_Client_Call) Run(run func(ctx context.Context, repo repository.ReaderWriter, opts RepositoryResourcesOptions)) *MockRepositoryResourcesFactory_Client_Call { +func (_c *MockRepositoryResourcesFactory_Client_Call) Run(run func(ctx context.Context, repo repository.ReaderWriter)) *MockRepositoryResourcesFactory_Client_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(context.Context), args[1].(repository.ReaderWriter), args[2].(RepositoryResourcesOptions)) + run(args[0].(context.Context), args[1].(repository.ReaderWriter)) }) return _c } @@ -77,7 +76,7 @@ func (_c *MockRepositoryResourcesFactory_Client_Call) Return(_a0 RepositoryResou return _c } -func (_c *MockRepositoryResourcesFactory_Client_Call) RunAndReturn(run func(context.Context, repository.ReaderWriter, RepositoryResourcesOptions) (RepositoryResources, error)) *MockRepositoryResourcesFactory_Client_Call { +func (_c *MockRepositoryResourcesFactory_Client_Call) RunAndReturn(run func(context.Context, repository.ReaderWriter) (RepositoryResources, error)) *MockRepositoryResourcesFactory_Client_Call { _c.Call.Return(run) return _c } diff --git a/pkg/registry/apis/provisioning/resources/resources.go b/pkg/registry/apis/provisioning/resources/resources.go index 7836581ddd1..9a144e19a34 100644 --- a/pkg/registry/apis/provisioning/resources/resources.go +++ b/pkg/registry/apis/provisioning/resources/resources.go @@ -41,17 +41,15 @@ type ResourcesManager struct { folders *FolderManager parser Parser clients ResourceClients - userInfo map[string]repository.CommitSignature resourcesLookup map[resourceID]string // the path with this k8s name } -func NewResourcesManager(repo repository.ReaderWriter, folders *FolderManager, parser Parser, clients ResourceClients, userInfo map[string]repository.CommitSignature) *ResourcesManager { +func NewResourcesManager(repo repository.ReaderWriter, folders *FolderManager, parser Parser, clients ResourceClients) *ResourcesManager { return &ResourcesManager{ repo: repo, folders: folders, parser: parser, clients: clients, - userInfo: userInfo, resourcesLookup: map[resourceID]string{}, } } @@ -78,8 +76,6 @@ func (r *ResourcesManager) CreateResourceFileFromObject(ctx context.Context, obj } } - ctx = r.withAuthorSignature(ctx, meta) - name := meta.GetName() if name == "" { return "", ErrMissingName @@ -233,26 +229,3 @@ func (r *ResourcesManager) RemoveResourceFromFile(ctx context.Context, path stri return objName, schema.GroupVersionKind{}, nil } - -func (r *ResourcesManager) withAuthorSignature(ctx context.Context, item utils.GrafanaMetaAccessor) context.Context { - id := item.GetUpdatedBy() - if id == "" { - id = item.GetCreatedBy() - } - if id == "" { - id = "grafana" - } - - sig := r.userInfo[id] // lookup - if sig.Name == "" && sig.Email == "" { - sig.Name = id - } - t, err := item.GetUpdatedTimestamp() - if err == nil && t != nil { - sig.When = *t - } else { - sig.When = item.GetCreationTimestamp().Time - } - - return repository.WithAuthorSignature(ctx, sig) -} diff --git a/pkg/registry/apis/provisioning/resources/signature/grafana.go b/pkg/registry/apis/provisioning/resources/signature/grafana.go new file mode 100644 index 00000000000..0bb70b8ad70 --- /dev/null +++ b/pkg/registry/apis/provisioning/resources/signature/grafana.go @@ -0,0 +1,33 @@ +package signature + +import ( + "context" + + "github.com/grafana/grafana/pkg/apimachinery/utils" + "github.com/grafana/grafana/pkg/registry/apis/provisioning/repository" +) + +type grafanaSigner struct{} + +// FIXME: where should we use this default signature? +// NewGrafanaSigner returns a Signer that uses the grafana user as the author +func NewGrafanaSigner() Signer { + return &grafanaSigner{} +} + +func (s *grafanaSigner) Sign(ctx context.Context, item utils.GrafanaMetaAccessor) (context.Context, error) { + sig := repository.CommitSignature{ + Name: "grafana", + // TODO: should we add email? + // Email: "grafana@grafana.com", + } + + t, err := item.GetUpdatedTimestamp() + if err == nil && t != nil { + sig.When = *t + } else { + sig.When = item.GetCreationTimestamp().Time + } + + return repository.WithAuthorSignature(ctx, sig), nil +} diff --git a/pkg/registry/apis/provisioning/resources/signature/grafana_test.go b/pkg/registry/apis/provisioning/resources/signature/grafana_test.go new file mode 100644 index 00000000000..f2cc5e01cfc --- /dev/null +++ b/pkg/registry/apis/provisioning/resources/signature/grafana_test.go @@ -0,0 +1,90 @@ +package signature + +import ( + "context" + "errors" + "testing" + "time" + + "github.com/stretchr/testify/require" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + "github.com/grafana/grafana/pkg/apimachinery/utils" + "github.com/grafana/grafana/pkg/registry/apis/provisioning/repository" +) + +func TestNewGrafanaSigner(t *testing.T) { + signer := NewGrafanaSigner() + require.NotNil(t, signer, "signer should not be nil") + require.IsType(t, &grafanaSigner{}, signer, "signer should be of type *grafanaSigner") +} + +func TestGrafanaSigner_Sign(t *testing.T) { + tests := []struct { + name string + creationTimestamp time.Time + updateTimestampErr error + updatedTimestamp *time.Time + expectedTime time.Time + setupMocks func(meta *utils.MockGrafanaMetaAccessor) + }{ + { + name: "should use creation timestamp when no update timestamp", + creationTimestamp: time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC), + updatedTimestamp: ptr(time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)), + updateTimestampErr: errors.New("failed"), + expectedTime: time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC), + setupMocks: func(meta *utils.MockGrafanaMetaAccessor) { + meta.On("GetCreationTimestamp").Return(metav1.Time{Time: time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)}) + }, + }, + { + name: "should use creation timestamp when update timestamp is nil", + creationTimestamp: time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC), + updatedTimestamp: nil, + expectedTime: time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC), + setupMocks: func(meta *utils.MockGrafanaMetaAccessor) { + meta.On("GetCreationTimestamp").Return(metav1.Time{Time: time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)}) + }, + }, + { + name: "should use update timestamp when available", + creationTimestamp: time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC), + updatedTimestamp: ptr(time.Date(2024, 1, 2, 0, 0, 0, 0, time.UTC)), + expectedTime: time.Date(2024, 1, 2, 0, 0, 0, 0, time.UTC), + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + meta := utils.NewMockGrafanaMetaAccessor(t) + var updatedTime *time.Time + if tt.updatedTimestamp != nil { + updatedTime = tt.updatedTimestamp + } + meta.On("GetUpdatedTimestamp").Return(updatedTime, tt.updateTimestampErr) + + if tt.setupMocks != nil { + tt.setupMocks(meta) + } + + signer := NewGrafanaSigner() + ctx := context.Background() + + signedCtx, err := signer.Sign(ctx, meta) + require.NoError(t, err) + + // Verify the signature in the context + sig := repository.GetAuthorSignature(signedCtx) + require.NotNil(t, sig, "signature should be present in context") + require.Equal(t, "grafana", sig.Name) + require.Equal(t, tt.expectedTime, sig.When) + + meta.AssertExpectations(t) + }) + } +} + +func ptr[T any](v T) *T { + return &v +} diff --git a/pkg/registry/apis/provisioning/resources/signature/signature.go b/pkg/registry/apis/provisioning/resources/signature/signature.go new file mode 100644 index 00000000000..9ad606bb33e --- /dev/null +++ b/pkg/registry/apis/provisioning/resources/signature/signature.go @@ -0,0 +1,52 @@ +package signature + +import ( + "context" + "fmt" + + "github.com/grafana/grafana/pkg/apimachinery/utils" + "github.com/grafana/grafana/pkg/registry/apis/provisioning/resources" +) + +//go:generate mockery --name Signer --structname MockSigner --inpackage --filename signer_mock.go --with-expecter +type Signer interface { + Sign(ctx context.Context, item utils.GrafanaMetaAccessor) (context.Context, error) +} + +type SignOptions struct { + Namespace string + History bool +} + +// SignerFactory is a factory for creating Signers +// +//go:generate mockery --name SignerFactory --structname MockSignerFactory --inpackage --filename signature_factory_mock.go --with-expecter +type SignerFactory interface { + New(ctx context.Context, opts SignOptions) (Signer, error) +} + +type signerFactory struct { + clients resources.ClientFactory +} + +func NewSignerFactory(clients resources.ClientFactory) SignerFactory { + return &signerFactory{clients} +} + +func (f *signerFactory) New(ctx context.Context, opts SignOptions) (Signer, error) { + if !opts.History { + return NewGrafanaSigner(), nil + } + + clients, err := f.clients.Clients(ctx, opts.Namespace) + if err != nil { + return nil, fmt.Errorf("get clients: %w", err) + } + + userClient, err := clients.User() + if err != nil { + return nil, fmt.Errorf("get user client: %w", err) + } + + return NewLoadUsersOnceSigner(userClient), nil +} diff --git a/pkg/registry/apis/provisioning/resources/signature/signature_factory_mock.go b/pkg/registry/apis/provisioning/resources/signature/signature_factory_mock.go new file mode 100644 index 00000000000..6f67bc8ffda --- /dev/null +++ b/pkg/registry/apis/provisioning/resources/signature/signature_factory_mock.go @@ -0,0 +1,95 @@ +// Code generated by mockery v2.52.4. DO NOT EDIT. + +package signature + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" +) + +// MockSignerFactory is an autogenerated mock type for the SignerFactory type +type MockSignerFactory struct { + mock.Mock +} + +type MockSignerFactory_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSignerFactory) EXPECT() *MockSignerFactory_Expecter { + return &MockSignerFactory_Expecter{mock: &_m.Mock} +} + +// New provides a mock function with given fields: ctx, opts +func (_m *MockSignerFactory) New(ctx context.Context, opts SignOptions) (Signer, error) { + ret := _m.Called(ctx, opts) + + if len(ret) == 0 { + panic("no return value specified for New") + } + + var r0 Signer + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, SignOptions) (Signer, error)); ok { + return rf(ctx, opts) + } + if rf, ok := ret.Get(0).(func(context.Context, SignOptions) Signer); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(Signer) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, SignOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSignerFactory_New_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'New' +type MockSignerFactory_New_Call struct { + *mock.Call +} + +// New is a helper method to define mock.On call +// - ctx context.Context +// - opts SignOptions +func (_e *MockSignerFactory_Expecter) New(ctx interface{}, opts interface{}) *MockSignerFactory_New_Call { + return &MockSignerFactory_New_Call{Call: _e.mock.On("New", ctx, opts)} +} + +func (_c *MockSignerFactory_New_Call) Run(run func(ctx context.Context, opts SignOptions)) *MockSignerFactory_New_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(SignOptions)) + }) + return _c +} + +func (_c *MockSignerFactory_New_Call) Return(_a0 Signer, _a1 error) *MockSignerFactory_New_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSignerFactory_New_Call) RunAndReturn(run func(context.Context, SignOptions) (Signer, error)) *MockSignerFactory_New_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSignerFactory creates a new instance of MockSignerFactory. 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 NewMockSignerFactory(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSignerFactory { + mock := &MockSignerFactory{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/pkg/registry/apis/provisioning/resources/signature/signature_test.go b/pkg/registry/apis/provisioning/resources/signature/signature_test.go new file mode 100644 index 00000000000..2d8abdd2cd2 --- /dev/null +++ b/pkg/registry/apis/provisioning/resources/signature/signature_test.go @@ -0,0 +1,91 @@ +package signature + +import ( + "context" + "fmt" + "testing" + + "github.com/stretchr/testify/require" + + "github.com/grafana/grafana/pkg/registry/apis/provisioning/resources" +) + +func TestSignerFactory_New(t *testing.T) { + tests := []struct { + name string + opts SignOptions + setupMocks func(t *testing.T, clients *resources.MockClientFactory) + expectedType interface{} + expectedError string + }{ + { + name: "should return grafana signer when history is false", + opts: SignOptions{ + History: false, + }, + setupMocks: func(t *testing.T, clients *resources.MockClientFactory) { + // No mocks needed as we shouldn't call any clients + }, + expectedType: &grafanaSigner{}, + }, + { + name: "should return load users once signer when history is true", + opts: SignOptions{ + History: true, + Namespace: "test-ns", + }, + setupMocks: func(t *testing.T, clients *resources.MockClientFactory) { + mockResourceClients := resources.NewMockResourceClients(t) + clients.On("Clients", context.Background(), "test-ns").Return(mockResourceClients, nil) + mockResourceClients.On("User").Return(nil, nil) + }, + expectedType: &loadUsersOnceSigner{}, + }, + { + name: "should return error when clients factory fails", + opts: SignOptions{ + History: true, + Namespace: "test-ns", + }, + setupMocks: func(t *testing.T, clients *resources.MockClientFactory) { + clients.On("Clients", context.Background(), "test-ns").Return(nil, fmt.Errorf("clients error")) + }, + expectedError: "get clients: clients error", + }, + { + name: "should return error when user client fails", + opts: SignOptions{ + History: true, + Namespace: "test-ns", + }, + setupMocks: func(t *testing.T, clients *resources.MockClientFactory) { + mockResourceClients := resources.NewMockResourceClients(t) + clients.On("Clients", context.Background(), "test-ns").Return(mockResourceClients, nil) + mockResourceClients.On("User").Return(nil, fmt.Errorf("user client error")) + }, + expectedError: "get user client: user client error", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mockClients := resources.NewMockClientFactory(t) + tt.setupMocks(t, mockClients) + + factory := NewSignerFactory(mockClients) + signer, err := factory.New(context.Background(), tt.opts) + + if tt.expectedError != "" { + require.Error(t, err) + require.EqualError(t, err, tt.expectedError) + require.Nil(t, signer) + } else { + require.NoError(t, err) + require.NotNil(t, signer) + require.IsType(t, tt.expectedType, signer, "signer should be of expected type") + } + + mockClients.AssertExpectations(t) + }) + } +} diff --git a/pkg/registry/apis/provisioning/resources/signature/signer_mock.go b/pkg/registry/apis/provisioning/resources/signature/signer_mock.go new file mode 100644 index 00000000000..93532369d5c --- /dev/null +++ b/pkg/registry/apis/provisioning/resources/signature/signer_mock.go @@ -0,0 +1,96 @@ +// Code generated by mockery v2.52.4. DO NOT EDIT. + +package signature + +import ( + context "context" + + utils "github.com/grafana/grafana/pkg/apimachinery/utils" + mock "github.com/stretchr/testify/mock" +) + +// MockSigner is an autogenerated mock type for the Signer type +type MockSigner struct { + mock.Mock +} + +type MockSigner_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSigner) EXPECT() *MockSigner_Expecter { + return &MockSigner_Expecter{mock: &_m.Mock} +} + +// Sign provides a mock function with given fields: ctx, item +func (_m *MockSigner) Sign(ctx context.Context, item utils.GrafanaMetaAccessor) (context.Context, error) { + ret := _m.Called(ctx, item) + + if len(ret) == 0 { + panic("no return value specified for Sign") + } + + var r0 context.Context + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, utils.GrafanaMetaAccessor) (context.Context, error)); ok { + return rf(ctx, item) + } + if rf, ok := ret.Get(0).(func(context.Context, utils.GrafanaMetaAccessor) context.Context); ok { + r0 = rf(ctx, item) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(context.Context) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, utils.GrafanaMetaAccessor) error); ok { + r1 = rf(ctx, item) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSigner_Sign_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sign' +type MockSigner_Sign_Call struct { + *mock.Call +} + +// Sign is a helper method to define mock.On call +// - ctx context.Context +// - item utils.GrafanaMetaAccessor +func (_e *MockSigner_Expecter) Sign(ctx interface{}, item interface{}) *MockSigner_Sign_Call { + return &MockSigner_Sign_Call{Call: _e.mock.On("Sign", ctx, item)} +} + +func (_c *MockSigner_Sign_Call) Run(run func(ctx context.Context, item utils.GrafanaMetaAccessor)) *MockSigner_Sign_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(utils.GrafanaMetaAccessor)) + }) + return _c +} + +func (_c *MockSigner_Sign_Call) Return(_a0 context.Context, _a1 error) *MockSigner_Sign_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSigner_Sign_Call) RunAndReturn(run func(context.Context, utils.GrafanaMetaAccessor) (context.Context, error)) *MockSigner_Sign_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSigner creates a new instance of MockSigner. 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 NewMockSigner(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSigner { + mock := &MockSigner{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/pkg/registry/apis/provisioning/resources/signature/users.go b/pkg/registry/apis/provisioning/resources/signature/users.go new file mode 100644 index 00000000000..1375a850ed7 --- /dev/null +++ b/pkg/registry/apis/provisioning/resources/signature/users.go @@ -0,0 +1,115 @@ +package signature + +import ( + "context" + "errors" + "fmt" + "strings" + "sync" + + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/client-go/dynamic" + + "github.com/grafana/grafana/pkg/apimachinery/utils" + "github.com/grafana/grafana/pkg/registry/apis/provisioning/repository" + "github.com/grafana/grafana/pkg/registry/apis/provisioning/resources" +) + +const maxUsers = 10000 + +type loadUsersOnceSigner struct { + signatures map[string]repository.CommitSignature + client dynamic.ResourceInterface + once sync.Once + onceErr error +} + +// NewLoadUsersOnceSigner returns a Signer that loads the signatures from users +// it will only load the signatures once and cache them +// if the user is not found, it will use the grafana user as the author +func NewLoadUsersOnceSigner(client dynamic.ResourceInterface) Signer { + return &loadUsersOnceSigner{ + client: client, + once: sync.Once{}, + signatures: map[string]repository.CommitSignature{}, + } +} + +func (s *loadUsersOnceSigner) Sign(ctx context.Context, item utils.GrafanaMetaAccessor) (context.Context, error) { + if s.onceErr != nil { + return ctx, fmt.Errorf("load signatures: %w", s.onceErr) + } + + var err error + s.once.Do(func() { + s.signatures, err = s.load(ctx, s.client) + s.onceErr = err + }) + if err != nil { + return ctx, fmt.Errorf("load signatures: %w", err) + } + + id := item.GetUpdatedBy() + if id == "" { + id = item.GetCreatedBy() + } + if id == "" { + id = "grafana" + } + + sig := s.signatures[id] // lookup + if sig.Name == "" && sig.Email == "" { + sig.Name = id + } + t, err := item.GetUpdatedTimestamp() + if err == nil && t != nil { + sig.When = *t + } else { + sig.When = item.GetCreationTimestamp().Time + } + + return repository.WithAuthorSignature(ctx, sig), nil +} + +func (s *loadUsersOnceSigner) load(ctx context.Context, client dynamic.ResourceInterface) (map[string]repository.CommitSignature, error) { + userInfo := make(map[string]repository.CommitSignature) + var count int + err := resources.ForEach(ctx, client, func(item *unstructured.Unstructured) error { + count++ + if count > maxUsers { + return errors.New("too many users") + } + + sig := repository.CommitSignature{} + // FIXME: should we improve logging here? + var ( + ok bool + err error + ) + + sig.Name, ok, err = unstructured.NestedString(item.Object, "spec", "login") + if !ok || err != nil { + return nil + } + sig.Email, ok, err = unstructured.NestedString(item.Object, "spec", "email") + if !ok || err != nil { + return nil + } + + if sig.Name == sig.Email { + if sig.Name == "" { + sig.Name = item.GetName() + } else if strings.Contains(sig.Email, "@") { + sig.Email = "" // don't use the same value for name+email + } + } + + userInfo["user:"+item.GetName()] = sig + return nil + }) + if err != nil { + return nil, err + } + + return userInfo, nil +} diff --git a/pkg/registry/apis/provisioning/resources/signature/users_test.go b/pkg/registry/apis/provisioning/resources/signature/users_test.go new file mode 100644 index 00000000000..37a1e31fe92 --- /dev/null +++ b/pkg/registry/apis/provisioning/resources/signature/users_test.go @@ -0,0 +1,357 @@ +package signature + +import ( + "context" + "errors" + "fmt" + "testing" + "time" + + "github.com/stretchr/testify/require" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" + "k8s.io/client-go/dynamic" + + "github.com/grafana/grafana/pkg/apimachinery/utils" + "github.com/grafana/grafana/pkg/registry/apis/provisioning/repository" +) + +// mockDynamicInterface implements a simplified version of the dynamic.ResourceInterface +type mockDynamicInterface struct { + dynamic.ResourceInterface + items []unstructured.Unstructured + err error +} + +func (m *mockDynamicInterface) List(ctx context.Context, opts metav1.ListOptions) (*unstructured.UnstructuredList, error) { + if m.err != nil { + return nil, m.err + } + return &unstructured.UnstructuredList{ + Items: m.items, + }, nil +} + +type mockGrafanaMetaAccessor struct { + utils.GrafanaMetaAccessor + createdBy string + updatedBy string + creationTimestamp time.Time + updatedTimestamp *time.Time + updatedTimestampErr error +} + +func (m *mockGrafanaMetaAccessor) GetCreatedBy() string { + return m.createdBy +} + +func (m *mockGrafanaMetaAccessor) GetUpdatedBy() string { + return m.updatedBy +} + +func (m *mockGrafanaMetaAccessor) GetCreationTimestamp() metav1.Time { + return metav1.Time{Time: m.creationTimestamp} +} + +func (m *mockGrafanaMetaAccessor) GetUpdatedTimestamp() (*time.Time, error) { + if m.updatedTimestampErr != nil { + return nil, m.updatedTimestampErr + } + return m.updatedTimestamp, nil +} + +func TestLoadUsersOnceSigner_Sign(t *testing.T) { + baseTime := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC) + updateTime := time.Date(2024, 1, 2, 0, 0, 0, 0, time.UTC) + + tests := []struct { + name string + items []unstructured.Unstructured + meta *mockGrafanaMetaAccessor + clientErr error + expectedSig repository.CommitSignature + expectedError string + }{ + { + name: "should sign with user info when user exists", + items: []unstructured.Unstructured{ + { + Object: map[string]interface{}{ + "metadata": map[string]interface{}{ + "name": "user1", + }, + "spec": map[string]interface{}{ + "login": "johndoe", + "email": "john@example.com", + }, + }, + }, + }, + meta: &mockGrafanaMetaAccessor{ + updatedBy: "user:user1", + creationTimestamp: baseTime, + updatedTimestamp: &updateTime, + }, + expectedSig: repository.CommitSignature{ + Name: "johndoe", + Email: "john@example.com", + When: updateTime, + }, + }, + { + name: "should fallback to created by when updated by is empty", + items: []unstructured.Unstructured{ + { + Object: map[string]interface{}{ + "metadata": map[string]interface{}{ + "name": "user1", + }, + "spec": map[string]interface{}{ + "login": "johndoe", + "email": "john@example.com", + }, + }, + }, + }, + meta: &mockGrafanaMetaAccessor{ + createdBy: "user:user1", + creationTimestamp: baseTime, + }, + expectedSig: repository.CommitSignature{ + Name: "johndoe", + Email: "john@example.com", + When: baseTime, + }, + }, + { + name: "should use grafana when no user info available", + meta: &mockGrafanaMetaAccessor{ + creationTimestamp: baseTime, + }, + expectedSig: repository.CommitSignature{ + Name: "grafana", + When: baseTime, + }, + }, + { + name: "should handle user with same login and email", + items: []unstructured.Unstructured{ + { + Object: map[string]interface{}{ + "metadata": map[string]interface{}{ + "name": "user1", + }, + "spec": map[string]interface{}{ + "login": "john@example.com", + "email": "john@example.com", + }, + }, + }, + }, + meta: &mockGrafanaMetaAccessor{ + updatedBy: "user:user1", + creationTimestamp: baseTime, + updatedTimestamp: &updateTime, + }, + expectedSig: repository.CommitSignature{ + Name: "john@example.com", + Email: "", + When: updateTime, + }, + }, + { + name: "should handle empty login and email", + items: []unstructured.Unstructured{ + { + Object: map[string]interface{}{ + "metadata": map[string]interface{}{ + "name": "user1", + }, + "spec": map[string]interface{}{ + "login": "", + "email": "", + }, + }, + }, + }, + meta: &mockGrafanaMetaAccessor{ + updatedBy: "user:user1", + creationTimestamp: baseTime, + updatedTimestamp: &updateTime, + }, + expectedSig: repository.CommitSignature{ + Name: "user1", + Email: "", + When: updateTime, + }, + }, + { + name: "should handle empty email", + items: []unstructured.Unstructured{ + { + Object: map[string]interface{}{ + "metadata": map[string]interface{}{ + "name": "user1", + }, + "spec": map[string]interface{}{ + "login": "johndoe", + "email": "", + }, + }, + }, + }, + meta: &mockGrafanaMetaAccessor{ + updatedBy: "user:user1", + creationTimestamp: baseTime, + updatedTimestamp: &updateTime, + }, + expectedSig: repository.CommitSignature{ + Name: "johndoe", + Email: "", + When: updateTime, + }, + }, + { + name: "should fail when too many users", + items: func() []unstructured.Unstructured { + items := make([]unstructured.Unstructured, maxUsers+1) + for i := 0; i < maxUsers+1; i++ { + items[i] = unstructured.Unstructured{ + Object: map[string]interface{}{ + "metadata": map[string]interface{}{ + "name": "user1", + }, + "spec": map[string]interface{}{ + "login": "johndoe", + "email": "john@example.com", + }, + }, + } + } + return items + }(), + meta: &mockGrafanaMetaAccessor{ + updatedBy: "user:user1", + creationTimestamp: baseTime, + }, + expectedError: "load signatures: too many users", + }, + { + name: "should handle missing user fields gracefully", + items: []unstructured.Unstructured{ + { + Object: map[string]interface{}{ + "metadata": map[string]interface{}{ + "name": "user1", + }, + "spec": map[string]interface{}{ + // missing login and email + }, + }, + }, + }, + meta: &mockGrafanaMetaAccessor{ + updatedBy: "user:user1", + creationTimestamp: baseTime, + }, + expectedSig: repository.CommitSignature{ + Name: "user:user1", + When: baseTime, + }, + }, + { + name: "should use creation timestamp when update timestamp has error", + items: []unstructured.Unstructured{ + { + Object: map[string]interface{}{ + "metadata": map[string]interface{}{ + "name": "user1", + }, + "spec": map[string]interface{}{ + "login": "johndoe", + "email": "john@example.com", + }, + }, + }, + }, + meta: &mockGrafanaMetaAccessor{ + updatedBy: "user:user1", + creationTimestamp: baseTime, + updatedTimestampErr: errors.New("update timestamp error"), + }, + expectedSig: repository.CommitSignature{ + Name: "johndoe", + Email: "john@example.com", + When: baseTime, + }, + }, + { + name: "should fail when listing users fails", + meta: &mockGrafanaMetaAccessor{ + updatedBy: "user:user1", + creationTimestamp: baseTime, + }, + clientErr: fmt.Errorf("failed to list users"), + expectedError: "load signatures: error executing list: failed to list users", + }, + { + name: "should handle empty user list", + meta: &mockGrafanaMetaAccessor{ + updatedBy: "user:user1", + creationTimestamp: baseTime, + }, + items: []unstructured.Unstructured{}, + expectedSig: repository.CommitSignature{ + Name: "user:user1", + When: baseTime, + }, + }, + { + name: "should handle multiple calls with error", + meta: &mockGrafanaMetaAccessor{ + updatedBy: "user:user1", + creationTimestamp: baseTime, + }, + clientErr: fmt.Errorf("failed to list users"), + expectedError: "load signatures: error executing list: failed to list users", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + client := &mockDynamicInterface{ + items: tt.items, + err: tt.clientErr, + } + + signer := NewLoadUsersOnceSigner(client) + ctx := context.Background() + + signedCtx, err := signer.Sign(ctx, tt.meta) + + if tt.expectedError != "" { + require.Error(t, err) + require.Contains(t, err.Error(), tt.expectedError) + + // Test that subsequent calls also fail with the same error + _, err2 := signer.Sign(ctx, tt.meta) + require.Error(t, err2) + require.Contains(t, err2.Error(), tt.expectedError) + return + } + + require.NoError(t, err) + sig := repository.GetAuthorSignature(signedCtx) + require.NotNil(t, sig) + require.Equal(t, tt.expectedSig.Name, sig.Name) + require.Equal(t, tt.expectedSig.Email, sig.Email) + require.Equal(t, tt.expectedSig.When, sig.When) + + // Test that subsequent calls use cached data + signedCtx2, err := signer.Sign(ctx, tt.meta) + require.NoError(t, err) + sig2 := repository.GetAuthorSignature(signedCtx2) + require.Equal(t, sig, sig2) + }) + } +} diff --git a/pkg/registry/apis/provisioning/resources/users.go b/pkg/registry/apis/provisioning/resources/users.go deleted file mode 100644 index 07dc9acfe8e..00000000000 --- a/pkg/registry/apis/provisioning/resources/users.go +++ /dev/null @@ -1,57 +0,0 @@ -package resources - -import ( - "context" - "errors" - "strings" - - "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" - "k8s.io/client-go/dynamic" - - "github.com/grafana/grafana/pkg/registry/apis/provisioning/repository" -) - -const maxUsers = 10000 - -func loadUsers(ctx context.Context, client dynamic.ResourceInterface) (map[string]repository.CommitSignature, error) { - userInfo := make(map[string]repository.CommitSignature) - var count int - err := ForEach(ctx, client, func(item *unstructured.Unstructured) error { - count++ - if count > maxUsers { - return errors.New("too many users") - } - - sig := repository.CommitSignature{} - // FIXME: should we improve logging here? - var ( - ok bool - err error - ) - - sig.Name, ok, err = unstructured.NestedString(item.Object, "spec", "login") - if !ok || err != nil { - return nil - } - sig.Email, ok, err = unstructured.NestedString(item.Object, "spec", "email") - if !ok || err != nil { - return nil - } - - if sig.Name == sig.Email { - if sig.Name == "" { - sig.Name = item.GetName() - } else if strings.Contains(sig.Email, "@") { - sig.Email = "" // don't use the same value for name+email - } - } - - userInfo["user:"+item.GetName()] = sig - return nil - }) - if err != nil { - return nil, err - } - - return userInfo, nil -} diff --git a/pkg/registry/apis/provisioning/resources/users_test.go b/pkg/registry/apis/provisioning/resources/users_test.go deleted file mode 100644 index 696043376a9..00000000000 --- a/pkg/registry/apis/provisioning/resources/users_test.go +++ /dev/null @@ -1,195 +0,0 @@ -package resources - -import ( - "context" - "testing" - - "github.com/stretchr/testify/require" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" - "k8s.io/client-go/dynamic" - - "github.com/grafana/grafana/pkg/registry/apis/provisioning/repository" -) - -// mockDynamicInterface implements a simplified version of the dynamic.ResourceInterface -type mockDynamicInterface struct { - dynamic.ResourceInterface - items []unstructured.Unstructured -} - -func (m *mockDynamicInterface) List(ctx context.Context, opts metav1.ListOptions) (*unstructured.UnstructuredList, error) { - return &unstructured.UnstructuredList{ - Items: m.items, - }, nil -} - -func TestLoadUsers(t *testing.T) { - tests := []struct { - name string - items []unstructured.Unstructured - expectedUsers map[string]repository.CommitSignature - expectedError string - }{ - { - name: "should load users successfully", - items: []unstructured.Unstructured{ - { - Object: map[string]interface{}{ - "metadata": map[string]interface{}{ - "name": "user1", - }, - "spec": map[string]interface{}{ - "login": "johndoe", - "email": "john@example.com", - }, - }, - }, - { - Object: map[string]interface{}{ - "metadata": map[string]interface{}{ - "name": "user2", - }, - "spec": map[string]interface{}{ - "login": "janedoe", - "email": "jane@example.com", - }, - }, - }, - }, - expectedUsers: map[string]repository.CommitSignature{ - "user:user1": { - Name: "johndoe", - Email: "john@example.com", - }, - "user:user2": { - Name: "janedoe", - Email: "jane@example.com", - }, - }, - }, - { - name: "should handle missing email", - items: []unstructured.Unstructured{ - { - Object: map[string]interface{}{ - "metadata": map[string]interface{}{ - "name": "user1", - }, - "spec": map[string]interface{}{ - "login": "johndoe", - // email missing - }, - }, - }, - }, - expectedUsers: map[string]repository.CommitSignature{}, - }, - { - name: "should handle missing login", - items: []unstructured.Unstructured{ - { - Object: map[string]interface{}{ - "metadata": map[string]interface{}{ - "name": "user1", - }, - "spec": map[string]interface{}{ - // login missing - "email": "john@example.com", - }, - }, - }, - }, - expectedUsers: map[string]repository.CommitSignature{}, - }, - { - name: "should handle same login and email", - items: []unstructured.Unstructured{ - { - Object: map[string]interface{}{ - "metadata": map[string]interface{}{ - "name": "user1", - }, - "spec": map[string]interface{}{ - "login": "john@example.com", - "email": "john@example.com", - }, - }, - }, - }, - expectedUsers: map[string]repository.CommitSignature{ - "user:user1": { - Name: "john@example.com", - Email: "", // Email should be empty when same as login - }, - }, - }, - { - name: "should handle empty login and email", - items: []unstructured.Unstructured{ - { - Object: map[string]interface{}{ - "metadata": map[string]interface{}{ - "name": "user1", - }, - "spec": map[string]interface{}{ - "login": "", - "email": "", - }, - }, - }, - }, - expectedUsers: map[string]repository.CommitSignature{ - "user:user1": { - Name: "user1", // Should use metadata name when login is empty - Email: "", - }, - }, - }, - { - name: "should fail when too many users", - items: func() []unstructured.Unstructured { - items := make([]unstructured.Unstructured, maxUsers+1) - for i := 0; i < maxUsers+1; i++ { - items[i] = unstructured.Unstructured{ - Object: map[string]interface{}{ - "metadata": map[string]interface{}{ - "name": "user1", - }, - "spec": map[string]interface{}{ - "login": "johndoe", - "email": "john@example.com", - }, - }, - } - } - return items - }(), - expectedError: "too many users", - }, - { - name: "should handle empty user list", - items: []unstructured.Unstructured{}, - expectedUsers: map[string]repository.CommitSignature{}, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - client := &mockDynamicInterface{ - items: tt.items, - } - - userInfo, err := loadUsers(context.Background(), client) - - if tt.expectedError != "" { - require.Error(t, err) - require.Contains(t, err.Error(), tt.expectedError) - return - } - - require.NoError(t, err) - require.Equal(t, tt.expectedUsers, userInfo) - }) - } -}