Move alert endpoints filter parsing to single function

They are exactly the same, no reason to duplicate.

Signed-off-by: stuart nelson <stuartnelson3@gmail.com>

api/v2/api.go

@@ -206,25 +206,17 @@ func (api *API) getReceiversHandler(params receiver_ops.GetReceiversParams) midd
 
 func (api *API) getAlertsHandler(params alert_ops.GetAlertsParams) middleware.Responder {
 	var (
-		err            error
 		receiverFilter *regexp.Regexp
 		// Initialize result slice to prevent api returning `null` when there
 		// are no alerts present
-		res      = open_api_models.GettableAlerts{}
-		matchers = []*labels.Matcher{}
-		ctx      = params.HTTPRequest.Context()
+		res = open_api_models.GettableAlerts{}
+		ctx = params.HTTPRequest.Context()
 	)
 
-	if params.Filter != nil {
-		for _, matcherString := range params.Filter {
-			matcher, err := parse.Matcher(matcherString)
-			if err != nil {
-				level.Error(api.logger).Log("msg", "failed to parse matchers", "err", err)
-				return alert_ops.NewGetAlertsBadRequest().WithPayload(err.Error())
-			}
-
-			matchers = append(matchers, matcher)
-		}
+	matchers, err := parseFilter(params.Filter)
+	if err != nil {
+		level.Error(api.logger).Log("msg", "failed to parse matchers", "err", err)
+		return alertgroup_ops.NewGetAlertGroupsBadRequest().WithPayload(err.Error())
 	}
 
 	if params.Receiver != nil {
@@ -347,20 +339,12 @@ func (api *API) postAlertsHandler(params alert_ops.PostAlertsParams) middleware.
 }
 
 func (api *API) getAlertGroupsHandler(params alertgroup_ops.GetAlertGroupsParams) middleware.Responder {
-	var (
-		err            error
-		receiverFilter *regexp.Regexp
-		matchers       = []*labels.Matcher{}
-	)
+	var receiverFilter *regexp.Regexp
 
-	for _, matcherString := range params.Filter {
-		matcher, err := parse.Matcher(matcherString)
-		if err != nil {
-			level.Error(api.logger).Log("msg", "failed to parse matchers", "err", err)
-			return alertgroup_ops.NewGetAlertGroupsBadRequest().WithPayload(err.Error())
-		}
-
-		matchers = append(matchers, matcher)
+	matchers, err := parseFilter(params.Filter)
+	if err != nil {
+		level.Error(api.logger).Log("msg", "failed to parse matchers", "err", err)
+		return alertgroup_ops.NewGetAlertGroupsBadRequest().WithPayload(err.Error())
 	}
 
 	if params.Receiver != nil {
@@ -784,3 +768,16 @@ func postableSilenceToProto(s *open_api_models.PostableSilence) (*silencepb.Sile
 	}
 	return sil, nil
 }
+
+func parseFilter(filter []string) ([]*labels.Matcher, error) {
+	matchers := make([]*labels.Matcher, 0, len(filter))
+	for _, matcherString := range filter {
+		matcher, err := parse.Matcher(matcherString)
+		if err != nil {
+			return nil, err
+		}
+
+		matchers = append(matchers, matcher)
+	}
+	return matchers, nil
+}

test/with_api_v2/acceptance/api_test.go

@@ -165,3 +165,69 @@ receivers:
 		}
 	}
 }
+
+func TestFilterAlertRequest(t *testing.T) {
+	t.Parallel()
+
+	conf := `
+route:
+  receiver: "default"
+  group_by: []
+  group_wait:      1s
+  group_interval:  10m
+  repeat_interval: 1h
+
+inhibit_rules:
+  - source_match:
+      severity: 'critical'
+    target_match:
+      severity: 'warning'
+    equal: ['alertname']
+
+receivers:
+- name: "default"
+  webhook_configs:
+  - url: 'http://%s'
+`
+
+	at := a.NewAcceptanceTest(t, &a.AcceptanceOpts{
+		Tolerance: 1 * time.Second,
+	})
+	co := at.Collector("webhook")
+	wh := a.NewWebhook(co)
+
+	amc := at.AlertmanagerCluster(fmt.Sprintf(conf, wh.Address()), 1)
+	require.NoError(t, amc.Start())
+	defer amc.Terminate()
+
+	am := amc.Members()[0]
+
+	now := time.Now()
+	startsAt := strfmt.DateTime(now)
+	endsAt := strfmt.DateTime(now.Add(5 * time.Minute))
+
+	labels := models.LabelSet(map[string]string{"alertname": "test1", "severity": "warning"})
+	pa1 := &models.PostableAlert{
+		StartsAt: startsAt,
+		EndsAt:   endsAt,
+		Alert:    models.Alert{Labels: labels},
+	}
+	labels = models.LabelSet(map[string]string{"system": "foo", "severity": "critical"})
+	pa2 := &models.PostableAlert{
+		StartsAt: startsAt,
+		EndsAt:   endsAt,
+		Alert:    models.Alert{Labels: labels},
+	}
+	alertParams := alert.NewPostAlertsParams()
+	alertParams.Alerts = models.PostableAlerts{pa1, pa2}
+	_, err := am.Client().Alert.PostAlerts(alertParams)
+	require.NoError(t, err)
+
+	filter := []string{"alertname=test1", "severity=warning"}
+	resp, err := am.Client().Alert.GetAlerts(alert.NewGetAlertsParams().WithFilter(filter))
+	require.NoError(t, err)
+	require.Equal(t, 1, len(resp.Payload))
+	for _, alert := range resp.Payload {
+		require.Equal(t, models.AlertStatusStateActive, *alert.Status.State)
+	}
+}