test(alerting): add tests for when to send notifcations

pkg/services/alerting/notifier.go

@@ -13,26 +13,32 @@ import (
 
 
 type NotifierImpl struct {
 type NotifierImpl struct {
 	log              log.Logger
 	log              log.Logger
+	getNotifications func(orgId int64, notificationGroups []int64) []*Notification
 }
 }
 
 
 func NewNotifier() *NotifierImpl {
 func NewNotifier() *NotifierImpl {
+	log := log.New("alerting.notifier")
 	return &NotifierImpl{
 	return &NotifierImpl{
-		log: log.New("alerting.notifier"),
+		log:              log,
+		getNotifications: buildGetNotifiers(log),
 	}
 	}
 }
 }
 
 
+func (n NotifierImpl) ShouldDispath(alertResult *AlertResult, notifier *Notification) bool {
+	warn := alertResult.State == alertstates.Warn && notifier.SendWarning
+	crit := alertResult.State == alertstates.Critical && notifier.SendCritical
+	return (warn || crit) || alertResult.State == alertstates.Ok
+}
+
 func (n *NotifierImpl) Notify(alertResult *AlertResult) {
 func (n *NotifierImpl) Notify(alertResult *AlertResult) {
-	notifiers := n.getNotifiers(alertResult.AlertJob.Rule.OrgId, alertResult.AlertJob.Rule.NotificationGroups)
+	notifiers := n.getNotifications(alertResult.AlertJob.Rule.OrgId, alertResult.AlertJob.Rule.NotificationGroups)
 
 
 	for _, notifier := range notifiers {
 	for _, notifier := range notifiers {
-		warn := alertResult.State == alertstates.Warn && notifier.SendWarning
-		crit := alertResult.State == alertstates.Critical && notifier.SendCritical
-		if (warn || crit) || alertResult.State == alertstates.Ok {
+		if n.ShouldDispath(alertResult, notifier) {
 			n.log.Info("Sending notification", "state", alertResult.State, "type", notifier.Type)
 			n.log.Info("Sending notification", "state", alertResult.State, "type", notifier.Type)
 			go notifier.Notifierr.Dispatch(alertResult)
 			go notifier.Notifierr.Dispatch(alertResult)
 		}
 		}
 	}
 	}
-
 }
 }
 
 
 type Notification struct {
 type Notification struct {
@@ -107,7 +113,8 @@ type NotificationDispatcher interface {
 	Dispatch(alertResult *AlertResult)
 	Dispatch(alertResult *AlertResult)
 }
 }
 
 
-func (n *NotifierImpl) getNotifiers(orgId int64, notificationGroups []int64) []*Notification {
+func buildGetNotifiers(log log.Logger) func(orgId int64, notificationGroups []int64) []*Notification {
+	return func(orgId int64, notificationGroups []int64) []*Notification {
 		query := &m.GetAlertNotificationQuery{
 		query := &m.GetAlertNotificationQuery{
 			OrgID:                orgId,
 			OrgID:                orgId,
 			Ids:                  notificationGroups,
 			Ids:                  notificationGroups,
@@ -115,21 +122,22 @@ func (n *NotifierImpl) getNotifiers(orgId int64, notificationGroups []int64) []*
 		}
 		}
 		err := bus.Dispatch(query)
 		err := bus.Dispatch(query)
 		if err != nil {
 		if err != nil {
-		n.log.Error("Failed to read notifications", "error", err)
+			log.Error("Failed to read notifications", "error", err)
 		}
 		}
 
 
 		var result []*Notification
 		var result []*Notification
-	n.log.Info("notifiriring", "count", len(query.Result), "groups", notificationGroups)
+		log.Info("notifiriring", "count", len(query.Result), "groups", notificationGroups)
 		for _, notification := range query.Result {
 		for _, notification := range query.Result {
 			not, err := NewNotificationFromDBModel(notification)
 			not, err := NewNotificationFromDBModel(notification)
 			if err == nil {
 			if err == nil {
 				result = append(result, not)
 				result = append(result, not)
 			} else {
 			} else {
-			n.log.Error("Failed to read notification model", "error", err)
+				log.Error("Failed to read notification model", "error", err)
 			}
 			}
 		}
 		}
 
 
 		return result
 		return result
+	}
 }
 }
 
 
 func NewNotificationFromDBModel(model *m.AlertNotification) (*Notification, error) {
 func NewNotificationFromDBModel(model *m.AlertNotification) (*Notification, error) {

pkg/services/alerting/notifier_test.go

@@ -7,12 +7,38 @@ import (
 
 
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	m "github.com/grafana/grafana/pkg/models"
 	m "github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/services/alerting/alertstates"
 	. "github.com/smartystreets/goconvey/convey"
 	. "github.com/smartystreets/goconvey/convey"
 )
 )
 
 
 func TestAlertNotificationExtraction(t *testing.T) {
 func TestAlertNotificationExtraction(t *testing.T) {
+	Convey("Notifier tests", t, func() {
+		Convey("rules for sending notifications", func() {
+			dummieNotifier := NotifierImpl{}
 
 
-	Convey("Parsing alert notification from settings", t, func() {
+			result := &AlertResult{
+				State: alertstates.Critical,
+			}
+
+			notifier := &Notification{
+				Name:         "Test Notifier",
+				Type:         "TestType",
+				SendCritical: true,
+				SendWarning:  true,
+			}
+
+			Convey("Should send notification", func() {
+				So(dummieNotifier.ShouldDispath(result, notifier), ShouldBeTrue)
+			})
+
+			Convey("warn:false and state:warn should not send", func() {
+				result.State = alertstates.Warn
+				notifier.SendWarning = false
+				So(dummieNotifier.ShouldDispath(result, notifier), ShouldBeFalse)
+			})
+		})
+
+		Convey("Parsing alert notification from settings", func() {
 			Convey("Parsing email", func() {
 			Convey("Parsing email", func() {
 				Convey("empty settings should return error", func() {
 				Convey("empty settings should return error", func() {
 					json := `{ }`
 					json := `{ }`
@@ -94,6 +120,6 @@ func TestAlertNotificationExtraction(t *testing.T) {
 					So(webhook.Url, ShouldEqual, "http://localhost:3000")
 					So(webhook.Url, ShouldEqual, "http://localhost:3000")
 				})
 				})
 			})
 			})
-
+		})
 	})
 	})
 }
 }