public/grafana
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Alerting: Add support for alpha rules apis in legacy storage

Browse Source 
Rules created in the new api makes the rule have no group in the database, but the rule is returned in the old group api with a sentinel group name formatted with the rule uid for compatiblity with the old api.
This makes the UI continue to work with the rules without a group, and the ruler will continue to work with the rules without a group.

Rules are not allowed to be created in the provisioning api with a NoGroup sentinel mask, but NoGroup rules can be manipulated through both the new and old apis.

Co-authored-by: William Wernert <william.wernert@grafana.com>
This commit is contained in:
Moustafa Baiou
2025-09-10 09:30:56 -04:00
committed by Moustafa Baiou
co-authored by William Wernert
parent 0a85a30642
commit ca8324e62a
50 changed files with 8729 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/services/ngalert/provisioning/alert_rules.go
+17 -4
View File
@@ -242,10 +242,13 @@ func (service *AlertRuleService) GetAlertRuleWithFolderFullpath(ctx context.Cont
}, nil
}
// CreateAlertRule creates a new alert rule. This function will ignore any
// interval that is set in the rule struct and use the already existing group
// interval or the default one.
// CreateAlertRule creates a new alert rule. For normal rule groups, this function will ignore any
// interval that is set in the rule struct and use the already existing group interval or the default one.
func (service *AlertRuleService) CreateAlertRule(ctx context.Context, user identity.Requester, rule models.AlertRule, provenance models.Provenance) (models.AlertRule, error) {
if models.IsNoGroupRuleGroup(rule.RuleGroup) {
return models.AlertRule{}, fmt.Errorf("%w: rules must have a valid group", models.ErrAlertRuleFailedValidation)
}
if rule.UID == "" {
rule.UID = util.GenerateShortUID()
} else if err := util.ValidateUID(rule.UID); err != nil {
@@ -281,7 +284,9 @@ func (service *AlertRuleService) CreateAlertRule(ctx context.Context, user ident
interval = existingGroup[0].IntervalSeconds
}
}
rule.IntervalSeconds = interval
if rule.RuleGroup != "" {
rule.IntervalSeconds = interval
}
err = rule.SetDashboardAndPanelFromAnnotations()
if err != nil {
return models.AlertRule{}, err
@@ -464,6 +469,11 @@ func (service *AlertRuleService) ReplaceRuleGroup(ctx context.Context, user iden
return err
}
// If the rule group is reserved for no-group rules, we cannot have multiple rules in it.
if models.IsNoGroupRuleGroup(group.Title) && len(group.Rules) > 1 {
return fmt.Errorf("rule group %s is reserved for no-group rules and cannot be used for rule groups with multiple rules", group.Title)
}
for _, rule := range group.Rules {
if rule.UID == "" {
// if empty the UID will be generated before save
@@ -653,6 +663,9 @@ func (service *AlertRuleService) persistDelta(ctx context.Context, user identity
},
})
}
if models.IsNoGroupRuleGroup(update.Existing.RuleGroup) && !models.IsNoGroupRuleGroup(update.New.RuleGroup) {
return fmt.Errorf("%w: cannot move rule out of this group", models.ErrAlertRuleFailedValidation)
}
updates = append(updates, models.UpdateRule{
Existing: update.Existing,
New: *update.New,
pkg/services/ngalert/provisioning/alert_rules_test.go
+418 -1
View File
@@ -4,6 +4,7 @@ import (
"context"
"encoding/json"
"errors"
"fmt"
"math/rand"
"slices"
"strconv"
@@ -748,6 +749,124 @@ func TestIntegrationAlertRuleService(t *testing.T) {
require.ErrorIs(t, err, models.ErrQuotaReached)
})
t.Run("alert rules created without a group should be considered NoGroup rules", func(t *testing.T) {
rule := createNoGroupRule("test-no-group-rule", orgID, "my-namespace")
// This is the way legacy storage creates rules without a group
rule.RuleGroup = ""
rule, err := ruleService.CreateAlertRule(context.Background(), u, rule, models.ProvenanceNone)
require.NoError(t, err)
require.Equal(t, int64(60), rule.IntervalSeconds)
rule, _, err = ruleService.GetAlertRule(context.Background(), u, rule.UID)
require.NoError(t, err)
require.True(t, models.IsNoGroupRuleGroup(rule.RuleGroup), "Rule should be considered NoGroup rule")
ruleGroup, err := ruleService.GetRuleGroup(context.Background(), u, rule.NamespaceUID, rule.RuleGroup)
require.NoError(t, err)
require.NotNil(t, ruleGroup)
require.True(t, models.IsNoGroupRuleGroup(ruleGroup.Title), "Rule group should be NoGroup rule group")
require.Len(t, ruleGroup.Rules, 1, "Rule group should only contain one NoGroup rule")
})
t.Run("multiple alert rules created without a group should be considered NoGroup rules, and be returned in separate groups", func(t *testing.T) {
rule := createNoGroupRule("test-no-group-rule-1", orgID, "my-namespace")
// This is the way legacy storage creates rules without a group
rule.RuleGroup = ""
rule, err := ruleService.CreateAlertRule(context.Background(), u, rule, models.ProvenanceNone)
require.NoError(t, err)
require.Equal(t, int64(60), rule.IntervalSeconds)
rule2 := createNoGroupRule("test-no-group-rule-2", orgID, "my-namespace")
// This is the way legacy storage creates rules without a group
rule2.RuleGroup = ""
rule2, err = ruleService.CreateAlertRule(context.Background(), u, rule2, models.ProvenanceNone)
require.NoError(t, err)
require.Equal(t, int64(60), rule.IntervalSeconds)
rule, _, err = ruleService.GetAlertRule(context.Background(), u, rule.UID)
require.NoError(t, err)
require.True(t, models.IsNoGroupRuleGroup(rule.RuleGroup), "Rule should be considered NoGroup rule")
rule2, _, err = ruleService.GetAlertRule(context.Background(), u, rule2.UID)
require.NoError(t, err)
require.True(t, models.IsNoGroupRuleGroup(rule2.RuleGroup), "Rule should be considered NoGroup rule")
require.NotEqual(t, rule.RuleGroup, rule2.RuleGroup, "Both rules should have different NoGroup rule groups")
ruleGroup, err := ruleService.GetRuleGroup(context.Background(), u, rule.NamespaceUID, rule.RuleGroup)
require.NoError(t, err)
require.NotNil(t, ruleGroup)
require.True(t, models.IsNoGroupRuleGroup(ruleGroup.Title), "Rule group should be NoGroup rule group")
require.Len(t, ruleGroup.Rules, 1, "Rule group should only contain one NoGroup rule")
ruleGroup2, err := ruleService.GetRuleGroup(context.Background(), u, rule2.NamespaceUID, rule2.RuleGroup)
require.NoError(t, err)
require.NotNil(t, ruleGroup2)
require.True(t, models.IsNoGroupRuleGroup(ruleGroup2.Title), "Rule group should be NoGroup rule group")
require.Len(t, ruleGroup2.Rules, 1, "Rule group should only contain one NoGroup rule")
require.NotEqual(t, ruleGroup, ruleGroup2, "Both NoGroup rule groups should be different")
})
t.Run("setting the group interval on NoGroup rules should only affect 1 rule", func(t *testing.T) {
rule := createNoGroupRule("test-no-group-rule-1", orgID, "my-namespace")
// This is the way legacy storage creates rules without a group
rule.RuleGroup = ""
rule, err := ruleService.CreateAlertRule(context.Background(), u, rule, models.ProvenanceNone)
require.NoError(t, err)
require.Equal(t, int64(60), rule.IntervalSeconds)
rule2 := createNoGroupRule("test-no-group-rule-2", orgID, "my-namespace")
// This is the way legacy storage creates rules without a group
rule2.RuleGroup = ""
rule2, err = ruleService.CreateAlertRule(context.Background(), u, rule2, models.ProvenanceNone)
require.NoError(t, err)
require.Equal(t, int64(60), rule.IntervalSeconds)
rule, _, err = ruleService.GetAlertRule(context.Background(), u, rule.UID)
require.NoError(t, err)
require.True(t, models.IsNoGroupRuleGroup(rule.RuleGroup), "Rule should be considered NoGroup rule")
rule2, _, err = ruleService.GetAlertRule(context.Background(), u, rule2.UID)
require.NoError(t, err)
require.True(t, models.IsNoGroupRuleGroup(rule2.RuleGroup), "Rule should be considered NoGroup rule")
require.NotEqual(t, rule.RuleGroup, rule2.RuleGroup, "Both rules should have different NoGroup rule groups")
var updatedInterval int64 = 120
err = ruleService.UpdateRuleGroup(context.Background(), u, rule.NamespaceUID, rule.RuleGroup, updatedInterval)
require.NoError(t, err)
rule, _, err = ruleService.GetAlertRule(context.Background(), u, rule.UID)
require.NoError(t, err)
require.Equal(t, updatedInterval, rule.IntervalSeconds, "Rule should have updated interval")
rule2, _, err = ruleService.GetAlertRule(context.Background(), u, rule2.UID)
require.NoError(t, err)
require.Equal(t, int64(60), rule2.IntervalSeconds, "Rule should not have updated interval")
require.NotEqual(t, updatedInterval, rule2.IntervalSeconds, "Both rules should not have updated interval")
})
t.Run("alert rule in NoGroup should be updated correctly", func(t *testing.T) {
rule := createNoGroupRule("test-no-group-rule", orgID, "my-namespace")
// This is the way legacy storage creates rules without a group
rule.RuleGroup = ""
rule, err := ruleService.CreateAlertRule(context.Background(), u, rule, models.ProvenanceNone)
require.NoError(t, err)
require.Equal(t, int64(60), rule.IntervalSeconds)
// get the actual calculated group for use with the api
rule, _, err = ruleService.GetAlertRule(context.Background(), u, rule.UID)
require.NoError(t, err)
require.True(t, models.IsNoGroupRuleGroup(rule.RuleGroup), "Rule should be considered NoGroup rule")
err = ruleService.UpdateRuleGroup(context.Background(), u, rule.NamespaceUID, rule.RuleGroup, 120)
require.NoError(t, err)
rule, _, err = ruleService.GetAlertRule(context.Background(), u, rule.UID)
require.NoError(t, err)
require.Equal(t, int64(120), rule.IntervalSeconds)
})
}
func TestIntegrationCreateAlertRule(t *testing.T) {
@@ -1028,6 +1147,25 @@ func TestIntegrationCreateAlertRule(t *testing.T) {
require.ErrorIs(t, err, models.ErrAlertRuleFailedValidation)
})
})
t.Run("should not allow creating with a NoGroup Rule", func(t *testing.T) {
// NoGroup rules are not allowed to be created directly via provisioning, they must be created via new k8s apis
ruleWNoGroup := createNoGroupRule("test_No_group_create_disallowed", orgID, "test-no-group-ns")
_, err := ruleService.CreateAlertRule(context.Background(), u, ruleWNoGroup, models.ProvenanceNone)
require.ErrorIs(t, err, models.ErrAlertRuleFailedValidation)
require.ErrorContains(t, err, "rules must have a valid group")
})
t.Run("should allow creating Rule without a group", func(t *testing.T) {
ruleWNoGroup := createNoGroupRule("test_No_group_create_allowed", orgID, "test-no-group-ns")
ruleWNoGroup.RuleGroup = "" // This is the way legacy storage creates rules without a group
_, err := ruleService.CreateAlertRule(context.Background(), u, ruleWNoGroup, models.ProvenanceNone)
require.NoError(t, err)
// We should be able to retrieve the rule and see that it is a NoGroup rule
retrievedRule, _, err := ruleService.GetAlertRule(context.Background(), u, ruleWNoGroup.UID)
require.NoError(t, err)
require.True(t, models.IsNoGroupRuleGroup(retrievedRule.RuleGroup), "Rule should be considered NoGroup rule")
})
}
func TestUpdateAlertRule(t *testing.T) {
@@ -1132,7 +1270,7 @@ func TestUpdateAlertRule(t *testing.T) {
})
t.Run("when there are no changes it should be successful", func(t *testing.T) {
// For this test we will not change the rule, and we will not use "admin" (CanWriteAllRulesFunc)
// For this test we will not change the rule, and we will not use "admin" (CanWriteAllRules)
// permissions. The response of the service should still be successful.
service, ruleStore, _, ac := initServiceWithData(t)
@@ -1155,6 +1293,29 @@ func TestUpdateAlertRule(t *testing.T) {
require.Empty(t, updates)
})
})
// NoGroup-specific tests for UpdateAlertRule
t.Run("NoGroup: UpdateAlertRule preserves interval and sentinel group", func(t *testing.T) {
service, ruleStore, provenanceStore, ac := initService(t)
ac.CanWriteAllRulesFunc = func(ctx context.Context, user identity.Requester) (bool, error) { return true, nil }
rule := createNoGroupRule("nogroup-update", orgID, "my-namespace")
_, err := ruleStore.InsertAlertRules(context.Background(), models.NewUserUID(u), []models.AlertRule{rule})
require.NoError(t, err)
require.NoError(t, provenanceStore.SetProvenance(context.Background(), &rule, orgID, models.ProvenanceNone))
// mutate fields and attempt to change interval via UpdateAlertRule
rule.Title = "nogroup-update-new"
originalInterval := int64(60)
require.Equal(t, originalInterval, rule.IntervalSeconds)
rule.IntervalSeconds = originalInterval + 60
updated, err := service.UpdateAlertRule(context.Background(), u, rule, models.ProvenanceNone)
require.NoError(t, err)
require.True(t, models.IsNoGroupRuleGroup(updated.RuleGroup))
require.Equal(t, "nogroup-update-new", updated.Title)
require.Equal(t, originalInterval, updated.IntervalSeconds)
})
}
func TestDeleteAlertRule(t *testing.T) {
@@ -1248,6 +1409,62 @@ func TestDeleteAlertRule(t *testing.T) {
require.Empty(t, deletes)
})
})
// NoGroup-specific behaviors
t.Run("deleting a NoGroup rule removes only that rule", func(t *testing.T) {
service, ruleStore, provenanceStore, ac := initService(t)
ac.CanWriteAllRulesFunc = func(ctx context.Context, user identity.Requester) (bool, error) { return true, nil }
// create two NoGroup rules in the same namespace (distinct sentinel groups)
r1 := createNoGroupRule("nogroup-del-1", orgID, "my-namespace")
r2 := createNoGroupRule("nogroup-del-2", orgID, "my-namespace")
_, err := ruleStore.InsertAlertRules(context.Background(), models.NewUserUID(u), []models.AlertRule{r1, r2})
require.NoError(t, err)
require.NoError(t, provenanceStore.SetProvenance(context.Background(), &r1, orgID, models.ProvenanceNone))
require.NoError(t, provenanceStore.SetProvenance(context.Background(), &r2, orgID, models.ProvenanceNone))
err = service.DeleteAlertRule(context.Background(), u, r1.UID, models.ProvenanceNone)
require.NoError(t, err)
deletes := getDeleteQueries(ruleStore)
require.Len(t, deletes, 1)
uids := deletes[0].Params[3].([]string)
require.Contains(t, uids, r1.UID)
// verify r2 remains in store
remaining := ruleStore.Rules[orgID]
require.Len(t, remaining, 1)
require.Equal(t, r2.UID, remaining[0].UID)
// and its sentinel group remains intact
require.True(t, models.IsNoGroupRuleGroup(remaining[0].RuleGroup))
})
t.Run("when user cannot write all rules, deleting a NoGroup rule authorizes and succeeds", func(t *testing.T) {
service, ruleStore, provenanceStore, ac := initService(t)
ac.CanWriteAllRulesFunc = func(ctx context.Context, user identity.Requester) (bool, error) { return false, nil }
r := createNoGroupRule("nogroup-del-auth", orgID, "my-namespace")
_, err := ruleStore.InsertAlertRules(context.Background(), models.NewUserUID(u), []models.AlertRule{r})
require.NoError(t, err)
require.NoError(t, provenanceStore.SetProvenance(context.Background(), &r, orgID, models.ProvenanceNone))
ac.AuthorizeRuleChangesFunc = func(ctx context.Context, user identity.Requester, change *store.GroupDelta) error {
// expect single delete and affected group contains exactly the rule
require.Len(t, change.Delete, 1)
require.Contains(t, change.AffectedGroups, change.GroupKey)
require.Len(t, change.AffectedGroups[change.GroupKey], 1)
require.Equal(t, r.UID, change.AffectedGroups[change.GroupKey][0].UID)
return nil
}
err = service.DeleteAlertRule(context.Background(), u, r.UID, models.ProvenanceNone)
require.NoError(t, err)
deletes := getDeleteQueries(ruleStore)
require.Len(t, deletes, 1)
uids := deletes[0].Params[3].([]string)
require.Contains(t, uids, r.UID)
})
}
func TestGetAlertRule(t *testing.T) {
@@ -1420,6 +1637,52 @@ func TestGetRuleGroup(t *testing.T) {
assert.Len(t, ac.Calls, 1)
assert.Equal(t, "CanReadAllRules", ac.Calls[0].Method)
})
// NoGroup-specific behaviors
// A NoGroup rule should be returned as a one-rule group addressed by its sentinel group title
t.Run("should return NoGroup rule group with exactly one rule", func(t *testing.T) {
service, ruleStore, _, ac := initService(t)
ac.CanReadAllRulesFunc = func(ctx context.Context, user identity.Requester) (bool, error) { return true, nil }
rule := createNoGroupRule("nogroup-rule-1", orgID, "my-namespace")
ruleStore.Rules = map[int64][]*models.AlertRule{
orgID: {&rule},
}
group, err := service.GetRuleGroup(context.Background(), u, rule.NamespaceUID, rule.RuleGroup)
require.NoError(t, err)
require.True(t, models.IsNoGroupRuleGroup(group.Title))
require.Equal(t, rule.NamespaceUID, group.FolderUID)
require.Equal(t, rule.IntervalSeconds, group.Interval)
require.Len(t, group.Rules, 1)
require.Equal(t, rule.UID, group.Rules[0].UID)
})
// Multiple NoGroup rules in the same namespace must produce separate sentinel groups
t.Run("should return distinct NoGroup groups for multiple rules", func(t *testing.T) {
service, ruleStore, _, ac := initService(t)
ac.CanReadAllRulesFunc = func(ctx context.Context, user identity.Requester) (bool, error) { return true, nil }
rule1 := createNoGroupRule("nogroup-rule-a", orgID, "my-namespace")
rule2 := createNoGroupRule("nogroup-rule-b", orgID, "my-namespace")
require.NotEqual(t, rule1.RuleGroup, rule2.RuleGroup)
ruleStore.Rules = map[int64][]*models.AlertRule{
orgID: {&rule1, &rule2},
}
group1, err := service.GetRuleGroup(context.Background(), u, rule1.NamespaceUID, rule1.RuleGroup)
require.NoError(t, err)
require.True(t, models.IsNoGroupRuleGroup(group1.Title))
require.Len(t, group1.Rules, 1)
require.Equal(t, rule1.UID, group1.Rules[0].UID)
group2, err := service.GetRuleGroup(context.Background(), u, rule2.NamespaceUID, rule2.RuleGroup)
require.NoError(t, err)
require.True(t, models.IsNoGroupRuleGroup(group2.Title))
require.Len(t, group2.Rules, 1)
require.Equal(t, rule2.UID, group2.Rules[0].UID)
})
}
func TestListAlertRules(t *testing.T) {
@@ -1761,6 +2024,36 @@ func TestReplaceGroup(t *testing.T) {
require.NoError(t, err)
require.Equal(t, "new", rule.Metadata.PrometheusStyleRule.OriginalRuleDefinition)
})
// NoGroup rule group should not allow more than one rule
t.Run("should reject multiple rules in a NoGroup rule group", func(t *testing.T) {
service, _, _, _ := initServiceWithData(t)
// Build a NoGroup group title and attempt to place 2 rules under it
group := createNoGroupRuleGroup("nogroup-multi", orgID, "my-namespace")
second := createNoGroupRule("nogroup-second", orgID, "my-namespace")
// Ensure the second rule is assigned to the same sentinel group
second.RuleGroup = group.Title
group.Rules = append(group.Rules, second)
err := service.ReplaceRuleGroup(context.Background(), u, group, models.ProvenanceNone)
require.Error(t, err)
require.ErrorContains(t, err, "cannot be used for rule groups with multiple rules")
})
t.Run("should reject changing the group name in a NoGroup rule group", func(t *testing.T) {
service, store, _, _ := initServiceWithData(t)
// Create a NoGroup rule and attempt to change its group name
groupSeed := createNoGroupRuleGroup("nogroup-multi", orgID, "my-namespace")
store.Rules[orgID] = []*models.AlertRule{models.CopyRule(&groupSeed.Rules[0])}
// change the group name away from the sentinel value
groupSeed.Title = "some-other-group" // not the sentinel group name
err := service.ReplaceRuleGroup(context.Background(), u, groupSeed, models.ProvenanceNone)
require.Error(t, err)
require.ErrorContains(t, err, "cannot move rule out of this group")
})
}
func TestDeleteRuleGroup(t *testing.T) {
@@ -2162,6 +2455,56 @@ func dummyRule(title string, orgID int64) models.AlertRule {
return createTestRule(title, "my-cool-group", orgID, "my-namespace")
}
func createNoGroupRuleGroup(title string, orgID int64, namespace string) models.AlertRuleGroup {
uid := util.GenerateShortUID()
group, err := models.NewNoGroupRuleGroup(uid)
if err != nil {
panic(fmt.Sprintf("failed to create NoGroupRuleGroup: %v", err))
}
return models.AlertRuleGroup{
Title: group.String(),
Interval: 60,
FolderUID: namespace,
Rules: []models.AlertRule{
createNoGroupRule(title, orgID, namespace),
},
}
}
func createNoGroupRule(title string, orgID int64, namespace string) models.AlertRule {
uid := util.GenerateShortUID()
group, err := models.NewNoGroupRuleGroup(uid)
if err != nil {
panic(fmt.Sprintf("failed to create NoGroupRuleGroup: %v", err))
}
return models.AlertRule{
UID: uid,
OrgID: orgID,
Title: title,
Condition: "A",
Version: 1,
IntervalSeconds: 60,
Data: []models.AlertQuery{
{
RefID: "A",
Model: json.RawMessage("{}"),
DatasourceUID: expr.DatasourceUID,
RelativeTimeRange: models.RelativeTimeRange{
From: models.Duration(60),
To: models.Duration(0),
},
},
},
NamespaceUID: namespace,
RuleGroup: group.String(),
For: time.Second * 60,
NoDataState: models.OK,
ExecErrState: models.OkErrState,
}
}
func createTestRule(title string, groupTitle string, orgID int64, namespace string) models.AlertRule {
return models.AlertRule{
OrgID: orgID,
@@ -2225,3 +2568,77 @@ func initService(t *testing.T) (*AlertRuleService, *fakes.RuleStore, *fakes.Fake
return service, ruleStore, provenanceStore, ac
}
// func TestNoGroupRuleGroupIntervalHandling(t *testing.T) {
// orgID := rand.Int63()
// u := &user.SignedInUser{OrgID: orgID, UserUID: util.GenerateShortUID()}
// t.Run("UpdateRuleGroup with NoGroupRuleGroup", func(t *testing.T) {
// t.Run("should allow interval updates for NoGroupRuleGroup via UpdateRuleGroup", func(t *testing.T) {
// service, store, _, ac := initService(t)
// ac.CanWriteAllRulesFunc = func(ctx context.Context, user identity.Requester) (bool, error) {
// return true, nil
// }
// // pre populate a rule with NoGroupRuleGroup
// rule := createNoGroupRule("test-rule", orgID, "my-namespace")
// store.Rules[orgID] = []*models.AlertRule{&rule} // Pre-populate the store with the rule
// // Update the rule with a new interval via UpdateRuleGroup
// newInterval := int64(120)
// createdRule, _, err := service.GetAlertRule(context.Background(), u, rule.UID)
// require.NoError(t, err)
// err = service.UpdateRuleGroup(context.Background(), u, createdRule.NamespaceUID, createdRule.RuleGroup, newInterval)
// require.NoError(t, err)
// updatedRule, _, err := service.GetAlertRule(context.Background(), u, createdRule.UID)
// require.NoError(t, err)
// assert.Equal(t, newInterval, updatedRule.IntervalSeconds, "Rule interval should be updated for NoGroupRuleGroup")
// })
// // t.Run("should preserve group interval for normal groups", func(t *testing.T) {
// // service, _, _, ac := initService(t)
// // ac.CanWriteAllRulesFunc = func(ctx context.Context, user identity.Requester) (bool, error) {
// // return true, nil
// // }
// // // Create a rule in a normal group
// // groupInterval := int64(90)
// // rule := createTestRule("test-rule", "normal-group", orgID, "my-namespace")
// // rule2 := createTestRule("test-rule-2", "normal-group", orgID, "my-namespace")
// // rule2.IntervalSeconds = groupInterval // Set the group interval
// // rule.IntervalSeconds = groupInterval
// // createdRule, err := service.CreateAlertRule(context.Background(), u, rule, models.ProvenanceNone)
// // require.NoError(t, err)
// // createdRule2, err := service.CreateAlertRule(context.Background(), u, rule2, models.ProvenanceNone)
// // require.NoError(t, err)
// // // Try to update the rule with a different interval
// // createdRule.IntervalSeconds = 120
// // updatedRule, err := service.UpdateAlertRule(context.Background(), u, createdRule, models.ProvenanceNone)
// // require.NoError(t, err)
// // assert.Equal(t, int64(120), updatedRule.IntervalSeconds, "Rule interval should be changed for all rules in normal groups")
// // updatedRule2, _, err := service.GetAlertRule(context.Background(), u, createdRule2.UID)
// // require.NoError(t, err)
// // assert.Equal(t, int64(120), updatedRule2.IntervalSeconds, "All rules in the same group should have the same interval after update")
// // })
// })
// t.Run("GetRuleGroup with a NoGroupRuleGroup", func(t *testing.T) {
// t.Run("should allow retrieval of sentinel group", func(t *testing.T) {
// service, store, _, ac := initService(t)
// ac.CanWriteAllRulesFunc = func(ctx context.Context, user identity.Requester) (bool, error) {
// return true, nil
// }
// // pre populate a rule with NoGroupRuleGroup
// rule := createNoGroupRule("test-rule", orgID, "my-namespace")
// store.Rules[orgID] = []*models.AlertRule{&rule} // Pre-populate the store with the rule
// noGroupGroup, err := service.GetRuleGroup(context.Background(), u, "my-namespace", rule.RuleGroup)
// require.NoError(t, err)
// assert.Equal(t, rule.RuleGroup, noGroupGroup.Title, "NoGroupRuleGroup should be retrievable by its group title")
// assert.Len(t, noGroupGroup.Rules, 1, "NoGroupRuleGroup should contain only the one rule")
// })
// })
// }