mirror of
https://github.com/grafana/grafana.git
synced 2025-02-25 18:55:37 -06:00
1108a00668
* support optimistic concurrency in template service * update request handler to get version from query parameter * return not found if a new template is set with version * update PUT api to set version * update documentation + for mute timings --------- Co-authored-by: brendamuir <100768211+brendamuir@users.noreply.github.com>
607 lines
24 KiB
Go
607 lines
24 KiB
Go
package provisioning
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
mock "github.com/stretchr/testify/mock"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/grafana/grafana/pkg/infra/log"
|
|
"github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions"
|
|
"github.com/grafana/grafana/pkg/services/ngalert/models"
|
|
"github.com/grafana/grafana/pkg/services/ngalert/notifier/legacy_storage"
|
|
"github.com/grafana/grafana/pkg/services/ngalert/provisioning/validation"
|
|
"github.com/grafana/grafana/pkg/setting"
|
|
)
|
|
|
|
func TestTemplateService(t *testing.T) {
|
|
t.Run("service returns templates from config file", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceAPI, nil)
|
|
|
|
result, err := sut.GetTemplates(context.Background(), 1)
|
|
|
|
require.NoError(t, err)
|
|
require.Len(t, result, 1)
|
|
})
|
|
|
|
t.Run("service returns empty map when config file contains no templates", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: defaultConfig,
|
|
})
|
|
|
|
result, err := sut.GetTemplates(context.Background(), 1)
|
|
|
|
require.NoError(t, err)
|
|
require.Empty(t, result)
|
|
})
|
|
|
|
t.Run("service propagates errors", func(t *testing.T) {
|
|
t.Run("when unable to read config", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetLatestAlertmanagerConfiguration(mock.Anything, mock.Anything).
|
|
Return(nil, fmt.Errorf("failed"))
|
|
|
|
_, err := sut.GetTemplates(context.Background(), 1)
|
|
|
|
require.Error(t, err)
|
|
})
|
|
|
|
t.Run("when config is invalid", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: brokenConfig,
|
|
})
|
|
|
|
_, err := sut.GetTemplates(context.Background(), 1)
|
|
|
|
require.Truef(t, legacy_storage.ErrBadAlertmanagerConfiguration.Base.Is(err), "expected ErrBadAlertmanagerConfiguration but got %s", err.Error())
|
|
})
|
|
|
|
t.Run("when no AM config in current org", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetLatestAlertmanagerConfiguration(mock.Anything, mock.Anything).
|
|
Return(nil, nil)
|
|
|
|
_, err := sut.GetTemplates(context.Background(), 1)
|
|
|
|
require.Truef(t, legacy_storage.ErrNoAlertmanagerConfiguration.Is(err), "expected ErrNoAlertmanagerConfiguration but got %s", err.Error())
|
|
})
|
|
})
|
|
|
|
t.Run("setting templates", func(t *testing.T) {
|
|
t.Run("rejects templates that fail validation", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
tmpl := definitions.NotificationTemplate{
|
|
Name: "",
|
|
Template: "",
|
|
}
|
|
|
|
_, err := sut.SetTemplate(context.Background(), 1, tmpl)
|
|
|
|
require.ErrorIs(t, err, ErrValidation)
|
|
})
|
|
|
|
t.Run("rejects existing templates if provenance is not right", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceAPI, nil)
|
|
|
|
expectedErr := errors.New("test")
|
|
sut.validator = func(from, to models.Provenance) error {
|
|
assert.Equal(t, models.ProvenanceAPI, from)
|
|
assert.Equal(t, models.ProvenanceNone, to)
|
|
return expectedErr
|
|
}
|
|
template := definitions.NotificationTemplate{
|
|
Name: "a",
|
|
Template: "asdf-new",
|
|
}
|
|
template.Provenance = definitions.Provenance(models.ProvenanceNone)
|
|
|
|
_, err := sut.SetTemplate(context.Background(), 1, template)
|
|
|
|
require.ErrorIs(t, err, expectedErr)
|
|
})
|
|
|
|
t.Run("rejects existing templates if version is not right", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
|
|
template := definitions.NotificationTemplate{
|
|
Name: "a",
|
|
Template: "asdf-new",
|
|
ResourceVersion: "bad-version",
|
|
Provenance: definitions.Provenance(models.ProvenanceNone),
|
|
}
|
|
|
|
_, err := sut.SetTemplate(context.Background(), 1, template)
|
|
|
|
require.ErrorIs(t, err, ErrVersionConflict)
|
|
})
|
|
|
|
t.Run("rejects new template if version is set", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
tmpl := createNotificationTemplate()
|
|
tmpl.ResourceVersion = "test"
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
mockStore.EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().SaveSucceeds()
|
|
|
|
_, err := sut.SetTemplate(context.Background(), 1, tmpl)
|
|
|
|
require.ErrorIs(t, err, ErrTemplateNotFound)
|
|
})
|
|
|
|
t.Run("propagates errors", func(t *testing.T) {
|
|
t.Run("when unable to read config", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
tmpl := createNotificationTemplate()
|
|
mockStore.EXPECT().
|
|
GetLatestAlertmanagerConfiguration(mock.Anything, mock.Anything).
|
|
Return(nil, fmt.Errorf("failed"))
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
|
|
_, err := sut.SetTemplate(context.Background(), 1, tmpl)
|
|
|
|
require.Error(t, err)
|
|
})
|
|
|
|
t.Run("when config is invalid", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
tmpl := createNotificationTemplate()
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: brokenConfig,
|
|
})
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
|
|
_, err := sut.SetTemplate(context.Background(), 1, tmpl)
|
|
|
|
require.Truef(t, legacy_storage.ErrBadAlertmanagerConfiguration.Base.Is(err), "expected ErrBadAlertmanagerConfiguration but got %s", err.Error())
|
|
})
|
|
|
|
t.Run("when no AM config in current org", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
tmpl := createNotificationTemplate()
|
|
mockStore.EXPECT().
|
|
GetLatestAlertmanagerConfiguration(mock.Anything, mock.Anything).
|
|
Return(nil, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
|
|
_, err := sut.SetTemplate(context.Background(), 1, tmpl)
|
|
|
|
require.Truef(t, legacy_storage.ErrNoAlertmanagerConfiguration.Is(err), "expected ErrNoAlertmanagerConfiguration but got %s", err.Error())
|
|
})
|
|
|
|
t.Run("when provenance fails to save", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
tmpl := createNotificationTemplate()
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
mockStore.EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().
|
|
SetProvenance(mock.Anything, mock.Anything, mock.Anything, mock.Anything).
|
|
Return(fmt.Errorf("failed to save provenance"))
|
|
|
|
_, err := sut.SetTemplate(context.Background(), 1, tmpl)
|
|
|
|
require.ErrorContains(t, err, "failed to save provenance")
|
|
})
|
|
|
|
t.Run("when AM config fails to save", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
tmpl := createNotificationTemplate()
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
mockStore.EXPECT().
|
|
UpdateAlertmanagerConfiguration(mock.Anything, mock.Anything).
|
|
Return(fmt.Errorf("failed to save config"))
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
|
|
_, err := sut.SetTemplate(context.Background(), 1, tmpl)
|
|
|
|
require.ErrorContains(t, err, "failed to save config")
|
|
})
|
|
})
|
|
|
|
t.Run("adds new template to config file on success", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
tmpl := createNotificationTemplate()
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
mockStore.EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().SaveSucceeds()
|
|
|
|
_, err := sut.SetTemplate(context.Background(), 1, tmpl)
|
|
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("succeeds when stitching config file with no templates", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
tmpl := createNotificationTemplate()
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: defaultConfig,
|
|
})
|
|
mockStore.EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().SaveSucceeds()
|
|
|
|
_, err := sut.SetTemplate(context.Background(), 1, tmpl)
|
|
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("normalizes template content with no define", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
tmpl := definitions.NotificationTemplate{
|
|
Name: "name",
|
|
Template: "content",
|
|
}
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: defaultConfig,
|
|
})
|
|
mockStore.EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().SaveSucceeds()
|
|
|
|
result, _ := sut.SetTemplate(context.Background(), 1, tmpl)
|
|
|
|
exp := "{{ define \"name\" }}\n content\n{{ end }}"
|
|
require.Equal(t, exp, result.Template)
|
|
})
|
|
|
|
t.Run("avoids normalizing template content with define", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
tmpl := definitions.NotificationTemplate{
|
|
Name: "name",
|
|
Template: "{{define \"name\"}}content{{end}}",
|
|
}
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: defaultConfig,
|
|
})
|
|
mockStore.EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().SaveSucceeds()
|
|
|
|
result, _ := sut.SetTemplate(context.Background(), 1, tmpl)
|
|
|
|
require.Equal(t, tmpl.Template, result.Template)
|
|
})
|
|
|
|
t.Run("rejects syntactically invalid template", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
tmpl := definitions.NotificationTemplate{
|
|
Name: "name",
|
|
Template: "{{ .MyField }",
|
|
}
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: defaultConfig,
|
|
})
|
|
mockStore.EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().SaveSucceeds()
|
|
|
|
_, err := sut.SetTemplate(context.Background(), 1, tmpl)
|
|
|
|
require.ErrorIs(t, err, ErrValidation)
|
|
})
|
|
|
|
t.Run("does not reject template with unknown field", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
tmpl := definitions.NotificationTemplate{
|
|
Name: "name",
|
|
Template: "{{ .NotAField }}",
|
|
}
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: defaultConfig,
|
|
})
|
|
mockStore.EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().SaveSucceeds()
|
|
|
|
_, err := sut.SetTemplate(context.Background(), 1, tmpl)
|
|
|
|
require.NoError(t, err)
|
|
})
|
|
})
|
|
|
|
t.Run("deleting templates", func(t *testing.T) {
|
|
t.Run("propagates errors", func(t *testing.T) {
|
|
t.Run("when unable to read config", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetLatestAlertmanagerConfiguration(mock.Anything, mock.Anything).
|
|
Return(nil, fmt.Errorf("failed"))
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceAPI, nil)
|
|
|
|
err := sut.DeleteTemplate(context.Background(), 1, "template", definitions.Provenance(models.ProvenanceAPI), "")
|
|
|
|
require.Error(t, err)
|
|
})
|
|
|
|
t.Run("when config is invalid", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: brokenConfig,
|
|
})
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceAPI, nil)
|
|
|
|
err := sut.DeleteTemplate(context.Background(), 1, "template", definitions.Provenance(models.ProvenanceAPI), "")
|
|
|
|
require.Truef(t, legacy_storage.ErrBadAlertmanagerConfiguration.Base.Is(err), "expected ErrBadAlertmanagerConfiguration but got %s", err.Error())
|
|
})
|
|
|
|
t.Run("when no AM config in current org", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetLatestAlertmanagerConfiguration(mock.Anything, mock.Anything).
|
|
Return(nil, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceAPI, nil)
|
|
|
|
err := sut.DeleteTemplate(context.Background(), 1, "template", definitions.Provenance(models.ProvenanceAPI), "")
|
|
|
|
require.Truef(t, legacy_storage.ErrNoAlertmanagerConfiguration.Is(err), "expected ErrNoAlertmanagerConfiguration but got %s", err.Error())
|
|
})
|
|
|
|
t.Run("when provenance fails to save", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
mockStore.EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceAPI, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().
|
|
DeleteProvenance(mock.Anything, mock.Anything, mock.Anything).
|
|
Return(fmt.Errorf("failed to save provenance"))
|
|
|
|
err := sut.DeleteTemplate(context.Background(), 1, "a", definitions.Provenance(models.ProvenanceAPI), "")
|
|
|
|
require.ErrorContains(t, err, "failed to save provenance")
|
|
})
|
|
|
|
t.Run("when AM config fails to save", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
mockStore.EXPECT().
|
|
UpdateAlertmanagerConfiguration(mock.Anything, mock.Anything).
|
|
Return(fmt.Errorf("failed to save config"))
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceAPI, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().SaveSucceeds()
|
|
|
|
err := sut.DeleteTemplate(context.Background(), 1, "a", definitions.Provenance(models.ProvenanceAPI), "")
|
|
|
|
require.ErrorContains(t, err, "failed to save config")
|
|
})
|
|
})
|
|
|
|
t.Run("deletes template from config file on success", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
mockStore.EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceAPI, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().SaveSucceeds()
|
|
|
|
err := sut.DeleteTemplate(context.Background(), 1, "a", definitions.Provenance(models.ProvenanceAPI), "")
|
|
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("deletes template from config file on success ignoring optimistic concurrency", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
mockStore.EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceAPI, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().SaveSucceeds()
|
|
|
|
err := sut.DeleteTemplate(context.Background(), 1, "a", definitions.Provenance(models.ProvenanceAPI), "b26e328af4bb9aaf")
|
|
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("does not error when deleting templates that do not exist", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
mockStore.EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceAPI, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().SaveSucceeds()
|
|
|
|
err := sut.DeleteTemplate(context.Background(), 1, "does not exist", definitions.Provenance(models.ProvenanceAPI), "")
|
|
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("succeeds when deleting from config file with no template section", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: defaultConfig,
|
|
})
|
|
mockStore.EXPECT().SaveSucceeds()
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceAPI, nil)
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().SaveSucceeds()
|
|
|
|
err := sut.DeleteTemplate(context.Background(), 1, "a", definitions.Provenance(models.ProvenanceAPI), "")
|
|
|
|
require.NoError(t, err)
|
|
})
|
|
|
|
t.Run("errors if provenance is not right", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceAPI, nil)
|
|
|
|
expectedErr := errors.New("test")
|
|
sut.validator = func(from, to models.Provenance) error {
|
|
assert.Equal(t, models.ProvenanceAPI, from)
|
|
assert.Equal(t, models.ProvenanceNone, to)
|
|
return expectedErr
|
|
}
|
|
|
|
err := sut.DeleteTemplate(context.Background(), 1, "a", definitions.Provenance(models.ProvenanceNone), "")
|
|
|
|
require.ErrorIs(t, err, expectedErr)
|
|
})
|
|
|
|
t.Run("errors if version is not right", func(t *testing.T) {
|
|
mockStore := &legacy_storage.MockAMConfigStore{}
|
|
sut := createTemplateServiceSut(legacy_storage.NewAlertmanagerConfigStore(mockStore))
|
|
mockStore.EXPECT().
|
|
GetsConfig(models.AlertConfiguration{
|
|
AlertmanagerConfiguration: configWithTemplates,
|
|
})
|
|
sut.provenanceStore.(*MockProvisioningStore).EXPECT().GetProvenance(mock.Anything, mock.Anything, mock.Anything).Return(models.ProvenanceNone, nil)
|
|
|
|
err := sut.DeleteTemplate(context.Background(), 1, "a", definitions.Provenance(models.ProvenanceNone), "bad-version")
|
|
|
|
require.ErrorIs(t, err, ErrVersionConflict)
|
|
})
|
|
})
|
|
}
|
|
|
|
func createTemplateServiceSut(configStore alertmanagerConfigStore) *TemplateService {
|
|
return &TemplateService{
|
|
configStore: configStore,
|
|
provenanceStore: &MockProvisioningStore{},
|
|
xact: newNopTransactionManager(),
|
|
log: log.NewNopLogger(),
|
|
validator: validation.ValidateProvenanceRelaxed,
|
|
}
|
|
}
|
|
|
|
func createNotificationTemplate() definitions.NotificationTemplate {
|
|
return definitions.NotificationTemplate{
|
|
Name: "test",
|
|
Template: "asdf",
|
|
}
|
|
}
|
|
|
|
var defaultConfig = setting.GetAlertmanagerDefaultConfiguration()
|
|
|
|
var configWithTemplates = `
|
|
{
|
|
"template_files": {
|
|
"a": "template"
|
|
},
|
|
"alertmanager_config": {
|
|
"route": {
|
|
"receiver": "grafana-default-email"
|
|
},
|
|
"receivers": [{
|
|
"name": "grafana-default-email",
|
|
"grafana_managed_receiver_configs": [{
|
|
"uid": "",
|
|
"name": "email receiver",
|
|
"type": "email",
|
|
"settings": {
|
|
"addresses": "<example@email.com>"
|
|
}
|
|
}]
|
|
}]
|
|
}
|
|
}
|
|
`
|
|
|
|
var brokenConfig = `
|
|
"alertmanager_config": {
|
|
"route": {
|
|
"receiver": "grafana-default-email"
|
|
},
|
|
"receivers": [{
|
|
"name": "grafana-default-email",
|
|
"grafana_managed_receiver_configs": [{
|
|
"uid": "abc",
|
|
"name": "default-email",
|
|
"type": "email",
|
|
"settings": {}
|
|
}]
|
|
}]
|
|
}
|
|
}`
|