LibraryElements: add fake service implementation and replace its usage in Dashboard API (#93783)

* LibraryElements: add fake service implementation

* Dashboards: replace fake LibraryElements implementation
This commit is contained in:
Matheus Macabu
2024-09-27 14:22:29 +02:00
committed by GitHub
parent 3437c8be7f
commit fcb17379ea
3 changed files with 264 additions and 43 deletions
@@ -0,0 +1,125 @@
package fake
import (
"context"
"sync"
"github.com/grafana/grafana/pkg/apimachinery/identity"
"github.com/grafana/grafana/pkg/services/libraryelements"
"github.com/grafana/grafana/pkg/services/libraryelements/model"
"github.com/grafana/grafana/pkg/util"
)
// LibraryElementService is a fake with only the required methods implemented while the others are stubbed.
type LibraryElementService struct {
elements map[string]model.LibraryElementDTO
mx sync.RWMutex
idCounter int64
}
var _ libraryelements.Service = (*LibraryElementService)(nil)
func (l *LibraryElementService) CreateElement(c context.Context, signedInUser identity.Requester, cmd model.CreateLibraryElementCommand) (model.LibraryElementDTO, error) {
l.mx.Lock()
defer l.mx.Unlock()
if len(l.elements) == 0 {
l.elements = make(map[string]model.LibraryElementDTO, 0)
}
var orgID int64 = 1
if signedInOrgID := signedInUser.GetOrgID(); signedInOrgID != 0 {
orgID = signedInOrgID
}
var folderUID string
if cmd.FolderUID != nil {
folderUID = *cmd.FolderUID
}
createUID := cmd.UID
if len(createUID) == 0 {
createUID = util.GenerateShortUID()
}
if _, exists := l.elements[createUID]; exists {
return model.LibraryElementDTO{}, model.ErrLibraryElementAlreadyExists
}
l.idCounter++
dto := model.LibraryElementDTO{
ID: l.idCounter,
OrgID: orgID,
FolderID: cmd.FolderID, //nolint: staticcheck
FolderUID: folderUID,
UID: createUID,
Name: cmd.Name,
Kind: cmd.Kind,
Type: "text",
Description: "A description",
Model: cmd.Model,
Version: 1,
Meta: model.LibraryElementDTOMeta{},
}
l.elements[createUID] = dto
return dto, nil
}
func (l *LibraryElementService) GetElement(c context.Context, signedInUser identity.Requester, cmd model.GetLibraryElementCommand) (model.LibraryElementDTO, error) {
l.mx.RLock()
defer l.mx.RUnlock()
libraryElement, exists := l.elements[cmd.UID]
if !exists {
return model.LibraryElementDTO{}, model.ErrLibraryElementNotFound
}
return libraryElement, nil
}
func (l *LibraryElementService) GetElementsForDashboard(c context.Context, dashboardID int64) (map[string]model.LibraryElementDTO, error) {
return map[string]model.LibraryElementDTO{}, nil
}
func (l *LibraryElementService) ConnectElementsToDashboard(c context.Context, signedInUser identity.Requester, elementUIDs []string, dashboardID int64) error {
return nil
}
func (l *LibraryElementService) DisconnectElementsFromDashboard(c context.Context, dashboardID int64) error {
return nil
}
func (l *LibraryElementService) DeleteLibraryElementsInFolder(c context.Context, signedInUser identity.Requester, folderUID string) error {
return nil
}
func (l *LibraryElementService) GetAllElements(c context.Context, signedInUser identity.Requester, query model.SearchLibraryElementsQuery) (model.LibraryElementSearchResult, error) {
elements := make([]model.LibraryElementDTO, 0, len(l.elements))
var orgID int64 = 1
if signedInOrgID := signedInUser.GetOrgID(); signedInOrgID != 0 {
orgID = signedInOrgID
}
l.mx.RLock()
defer l.mx.RUnlock()
for _, element := range l.elements {
if element.OrgID != orgID {
continue
}
elements = append(elements, element)
}
// For this fake ignore pagination to make it simpler.
return model.LibraryElementSearchResult{
TotalCount: int64(len(elements)),
Elements: elements,
Page: 1,
PerPage: len(elements),
}, nil
}
@@ -0,0 +1,132 @@
package fake_test
import (
"context"
"testing"
"github.com/stretchr/testify/require"
"github.com/grafana/grafana/pkg/apimachinery/identity"
"github.com/grafana/grafana/pkg/services/libraryelements/fake"
"github.com/grafana/grafana/pkg/services/libraryelements/model"
)
func TestLibraryElementService(t *testing.T) {
t.Parallel()
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
t.Run("GetElement", func(t *testing.T) {
t.Parallel()
user := &identity.StaticRequester{}
t.Run("when the element does not exist, it returns a `model.ErrLibraryElementNotFound` error", func(t *testing.T) {
t.Parallel()
svc := &fake.LibraryElementService{}
element, err := svc.GetElement(ctx, user, model.GetLibraryElementCommand{UID: "does-not-exist"})
require.ErrorIs(t, err, model.ErrLibraryElementNotFound)
require.Empty(t, element)
})
t.Run("when the element exists, it returns it", func(t *testing.T) {
t.Parallel()
svc := &fake.LibraryElementService{}
uid := "uid-1"
createdElement, err := svc.CreateElement(ctx, user, model.CreateLibraryElementCommand{
Name: "ElementName",
Model: []byte{},
Kind: int64(model.PanelElement),
UID: uid,
})
require.NoError(t, err)
require.NotEmpty(t, createdElement)
element, err := svc.GetElement(ctx, user, model.GetLibraryElementCommand{UID: uid})
require.NoError(t, err)
require.EqualValues(t, element, createdElement)
})
})
t.Run("CreateElement", func(t *testing.T) {
t.Parallel()
user := &identity.StaticRequester{}
t.Run("when the uid already exists, it returns a `model.ErrLibraryElementAlreadyExists` error", func(t *testing.T) {
t.Parallel()
svc := &fake.LibraryElementService{}
cmd := model.CreateLibraryElementCommand{
Name: "ElementName",
Model: []byte{},
Kind: int64(model.PanelElement),
UID: "uid-1",
}
createdElement, err := svc.CreateElement(ctx, user, cmd)
require.NoError(t, err)
require.NotEmpty(t, createdElement)
createdElement, err = svc.CreateElement(ctx, user, cmd)
require.ErrorIs(t, err, model.ErrLibraryElementAlreadyExists)
require.Empty(t, createdElement)
})
t.Run("when the uid is not passed in, it generates a new one", func(t *testing.T) {
t.Parallel()
svc := &fake.LibraryElementService{}
cmd := model.CreateLibraryElementCommand{
Name: "ElementName",
Model: []byte{},
Kind: int64(model.PanelElement),
}
createdElement, err := svc.CreateElement(ctx, user, cmd)
require.NoError(t, err)
require.NotEmpty(t, createdElement)
require.NotEmpty(t, createdElement.UID)
})
})
t.Run("GetAllElements", func(t *testing.T) {
t.Parallel()
t.Run("only returns the elements belonging to the requestor org", func(t *testing.T) {
t.Parallel()
user1 := &identity.StaticRequester{OrgID: 1}
user2 := &identity.StaticRequester{OrgID: 2}
svc := &fake.LibraryElementService{}
cmd := model.CreateLibraryElementCommand{
Name: "ElementName",
Model: []byte{},
Kind: int64(model.PanelElement),
}
createdElement1, err := svc.CreateElement(ctx, user1, cmd)
require.NoError(t, err)
require.NotEmpty(t, createdElement1)
createdElement2, err := svc.CreateElement(ctx, user2, cmd)
require.NoError(t, err)
require.NotEmpty(t, createdElement2)
result, err := svc.GetAllElements(ctx, user2, model.SearchLibraryElementsQuery{})
require.NoError(t, err)
require.Len(t, result.Elements, 1)
require.Equal(t, createdElement2.UID, result.Elements[0].UID)
})
})
}