fix(alerting): fix bug with unhandled error

closes #6239

pkg/services/alerting/extractor.go

@@ -80,6 +80,11 @@ func (e *DashAlertExtractor) GetAlerts() ([]*m.Alert, error) {
 				continue
 				continue
 			}
 			}
 
 
+			frequency, err := getTimeDurationStringToSeconds(jsonAlert.Get("frequency").MustString())
+			if err != nil {
+				return nil, ValidationError{Reason: "Could not parse frequency"}
+			}
+
 			alert := &m.Alert{
 			alert := &m.Alert{
 				DashboardId: e.Dash.Id,
 				DashboardId: e.Dash.Id,
 				OrgId:       e.OrgId,
 				OrgId:       e.OrgId,
@@ -88,7 +93,7 @@ func (e *DashAlertExtractor) GetAlerts() ([]*m.Alert, error) {
 				Name:        jsonAlert.Get("name").MustString(),
 				Name:        jsonAlert.Get("name").MustString(),
 				Handler:     jsonAlert.Get("handler").MustInt64(),
 				Handler:     jsonAlert.Get("handler").MustInt64(),
 				Message:     jsonAlert.Get("message").MustString(),
 				Message:     jsonAlert.Get("message").MustString(),
-				Frequency:   getTimeDurationStringToSeconds(jsonAlert.Get("frequency").MustString()),
+				Frequency:   frequency,
 			}
 			}
 
 
 			for _, condition := range jsonAlert.Get("conditions").MustArray() {
 			for _, condition := range jsonAlert.Get("conditions").MustArray() {
@@ -121,7 +126,7 @@ func (e *DashAlertExtractor) GetAlerts() ([]*m.Alert, error) {
 			alert.Settings = jsonAlert
 			alert.Settings = jsonAlert
 
 
 			// validate
 			// validate
-			_, err := NewRuleFromDBAlert(alert)
+			_, err = NewRuleFromDBAlert(alert)
 			if err == nil && alert.ValidToSave() {
 			if err == nil && alert.ValidToSave() {
 				alerts = append(alerts, alert)
 				alerts = append(alerts, alert)
 			} else {
 			} else {

pkg/services/alerting/rule.go

@@ -43,17 +43,27 @@ var unitMultiplier = map[string]int{
 	"h": 3600,
 	"h": 3600,
 }
 }
 
 
-func getTimeDurationStringToSeconds(str string) int64 {
+func getTimeDurationStringToSeconds(str string) (int64, error) {
 	multiplier := 1
 	multiplier := 1
 
 
-	value, _ := strconv.Atoi(ValueFormatRegex.FindAllString(str, 1)[0])
+	matches := ValueFormatRegex.FindAllString(str, 1)
+
+	if len(matches) <= 0 {
+		return 0, fmt.Errorf("Frequency could not be parsed")
+	}
+
+	value, err := strconv.Atoi(matches[0])
+	if err != nil {
+		return 0, err
+	}
+
 	unit := UnitFormatRegex.FindAllString(str, 1)[0]
 	unit := UnitFormatRegex.FindAllString(str, 1)[0]
 
 
 	if val, ok := unitMultiplier[unit]; ok {
 	if val, ok := unitMultiplier[unit]; ok {
 		multiplier = val
 		multiplier = val
 	}
 	}
 
 
-	return int64(value * multiplier)
+	return int64(value * multiplier), nil
 }
 }
 
 
 func NewRuleFromDBAlert(ruleDef *m.Alert) (*Rule, error) {
 func NewRuleFromDBAlert(ruleDef *m.Alert) (*Rule, error) {

pkg/services/alerting/rule_test.go

@@ -20,25 +20,30 @@ func TestAlertRuleModel(t *testing.T) {
 		})
 		})
 
 
 		Convey("Can parse seconds", func() {
 		Convey("Can parse seconds", func() {
-			seconds := getTimeDurationStringToSeconds("10s")
+			seconds, _ := getTimeDurationStringToSeconds("10s")
 			So(seconds, ShouldEqual, 10)
 			So(seconds, ShouldEqual, 10)
 		})
 		})
 
 
 		Convey("Can parse minutes", func() {
 		Convey("Can parse minutes", func() {
-			seconds := getTimeDurationStringToSeconds("10m")
+			seconds, _ := getTimeDurationStringToSeconds("10m")
 			So(seconds, ShouldEqual, 600)
 			So(seconds, ShouldEqual, 600)
 		})
 		})
 
 
 		Convey("Can parse hours", func() {
 		Convey("Can parse hours", func() {
-			seconds := getTimeDurationStringToSeconds("1h")
+			seconds, _ := getTimeDurationStringToSeconds("1h")
 			So(seconds, ShouldEqual, 3600)
 			So(seconds, ShouldEqual, 3600)
 		})
 		})
 
 
 		Convey("defaults to seconds", func() {
 		Convey("defaults to seconds", func() {
-			seconds := getTimeDurationStringToSeconds("1o")
+			seconds, _ := getTimeDurationStringToSeconds("1o")
 			So(seconds, ShouldEqual, 1)
 			So(seconds, ShouldEqual, 1)
 		})
 		})
 
 
+		Convey("should return err for empty string", func() {
+			_, err := getTimeDurationStringToSeconds("")
+			So(err, ShouldNotBeNil)
+		})
+
 		Convey("can construct alert rule model", func() {
 		Convey("can construct alert rule model", func() {
 			json := `
 			json := `
 			{
 			{