Alerting: Calculate diff for two AlertRules (#45877)

* add custom diff reporter DiffReporter that reports only paths that have a difference
* create Diff method for AlertRule that returns DiffReport, which is an alias for []Diff

Tests:
* create copy method for AlertRule in testing
* create GenerateAlertQuery method in testing

pkg/services/ngalert/models/testing.go

@@ -2,6 +2,7 @@ package models
 
 import (
 	"encoding/json"
+	"fmt"
 	"math/rand"
 	"time"
 
@@ -60,24 +61,11 @@ func AlertRuleGen(mutators ...func(*AlertRule)) func() *AlertRule {
 		}
 
 		rule := &AlertRule{
-			ID:        rand.Int63(),
-			OrgID:     rand.Int63(),
-			Title:     "TEST-ALERT-" + util.GenerateShortUID(),
-			Condition: "A",
-			Data: []AlertQuery{
-				{
-					DatasourceUID: "-100",
-					Model: json.RawMessage(`{
-			"datasourceUid": "-100",
-			"type":"math",
-			"expression":"2 + 1 < 1"
-		}`),
-					RelativeTimeRange: RelativeTimeRange{
-						From: Duration(5 * time.Hour),
-						To:   Duration(3 * time.Hour),
-					},
-					RefID: "A",
-				}},
+			ID:              rand.Int63(),
+			OrgID:           rand.Int63(),
+			Title:           "TEST-ALERT-" + util.GenerateShortUID(),
+			Condition:       "A",
+			Data:            []AlertQuery{GenerateAlertQuery()},
 			Updated:         time.Now().Add(-time.Duration(rand.Intn(100) + 1)),
 			IntervalSeconds: rand.Int63n(60) + 1,
 			Version:         rand.Int63(),
@@ -100,6 +88,25 @@ func AlertRuleGen(mutators ...func(*AlertRule)) func() *AlertRule {
 	}
 }
 
+func GenerateAlertQuery() AlertQuery {
+	f := rand.Intn(10) + 5
+	t := rand.Intn(f)
+
+	return AlertQuery{
+		DatasourceUID: util.GenerateShortUID(),
+		Model: json.RawMessage(fmt.Sprintf(`{
+			"%s": "%s",
+			"%s":"%d"
+		}`, util.GenerateShortUID(), util.GenerateShortUID(), util.GenerateShortUID(), rand.Int())),
+		RelativeTimeRange: RelativeTimeRange{
+			From: Duration(time.Duration(f) * time.Minute),
+			To:   Duration(time.Duration(t) * time.Minute),
+		},
+		RefID:     util.GenerateShortUID(),
+		QueryType: util.GenerateShortUID(),
+	}
+}
+
 // GenerateUniqueAlertRules generates many random alert rules and makes sure that they have unique UID.
 // It returns a tuple where first element is a map where keys are UID of alert rule and the second element is a slice of the same rules
 func GenerateUniqueAlertRules(count int, f func() *AlertRule) (map[string]*AlertRule, []*AlertRule) {
@@ -125,3 +132,59 @@ func GenerateAlertRules(count int, f func() *AlertRule) []*AlertRule {
 	}
 	return result
 }
+
+// CopyRule creates a deep copy of AlertRule
+func CopyRule(r *AlertRule) *AlertRule {
+	result := AlertRule{
+		ID:              r.ID,
+		OrgID:           r.OrgID,
+		Title:           r.Title,
+		Condition:       r.Condition,
+		Updated:         r.Updated,
+		IntervalSeconds: r.IntervalSeconds,
+		Version:         r.Version,
+		UID:             r.UID,
+		NamespaceUID:    r.NamespaceUID,
+		RuleGroup:       r.RuleGroup,
+		NoDataState:     r.NoDataState,
+		ExecErrState:    r.ExecErrState,
+		For:             r.For,
+	}
+
+	if r.DashboardUID != nil {
+		dash := *r.DashboardUID
+		result.DashboardUID = &dash
+	}
+	if r.PanelID != nil {
+		p := *r.PanelID
+		result.PanelID = &p
+	}
+
+	for _, d := range r.Data {
+		q := AlertQuery{
+			RefID:             d.RefID,
+			QueryType:         d.QueryType,
+			RelativeTimeRange: d.RelativeTimeRange,
+			DatasourceUID:     d.DatasourceUID,
+		}
+		q.Model = make([]byte, 0, cap(d.Model))
+		q.Model = append(q.Model, d.Model...)
+		result.Data = append(result.Data, q)
+	}
+
+	if r.Annotations != nil {
+		result.Annotations = make(map[string]string, len(r.Annotations))
+		for s, s2 := range r.Annotations {
+			result.Annotations[s] = s2
+		}
+	}
+
+	if r.Labels != nil {
+		result.Labels = make(map[string]string, len(r.Labels))
+		for s, s2 := range r.Labels {
+			result.Labels[s] = s2
+		}
+	}
+
+	return &result
+}