Alerting API: send 404 not found error and enrich delete with UID endpoint response with alert notification ID (#27550)

* Alerting API: Send back 404 not found error for update and delete endpoints

* Alerting API: send back alert notification id for delete with uid endpoint

(cherry picked from commit 0c4b7d3f5d)

pkg/services/sqlstore/alert_notification.go

@@ -33,9 +33,18 @@ func init() {
 func DeleteAlertNotification(cmd *models.DeleteAlertNotificationCommand) error {
 	return inTransaction(func(sess *DBSession) error {
 		sql := "DELETE FROM alert_notification WHERE alert_notification.org_id = ? AND alert_notification.id = ?"
-		if _, err := sess.Exec(sql, cmd.OrgId, cmd.Id); err != nil {
+		res, err := sess.Exec(sql, cmd.OrgId, cmd.Id)
+		if err != nil {
 			return err
 		}
+		rowsAffected, err := res.RowsAffected()
+		if err != nil {
+			return err
+		}
+
+		if rowsAffected == 0 {
+			return models.ErrAlertNotificationNotFound
+		}
 
 		if _, err := sess.Exec("DELETE FROM alert_notification_state WHERE alert_notification_state.org_id = ? AND alert_notification_state.notifier_id = ?", cmd.OrgId, cmd.Id); err != nil {
 			return err
@@ -51,14 +60,17 @@ func DeleteAlertNotificationWithUid(cmd *models.DeleteAlertNotificationWithUidCo
 		return err
 	}
 
-	if existingNotification.Result != nil {
-		deleteCommand := &models.DeleteAlertNotificationCommand{
-			Id:    existingNotification.Result.Id,
-			OrgId: existingNotification.Result.OrgId,
-		}
-		if err := bus.Dispatch(deleteCommand); err != nil {
-			return err
-		}
+	if existingNotification.Result == nil {
+		return models.ErrAlertNotificationNotFound
+	}
+
+	cmd.DeletedAlertNotificationId = existingNotification.Result.Id
+	deleteCommand := &models.DeleteAlertNotificationCommand{
+		Id:    existingNotification.Result.Id,
+		OrgId: existingNotification.Result.OrgId,
+	}
+	if err := bus.Dispatch(deleteCommand); err != nil {
+		return err
 	}
 
 	return nil
@@ -367,6 +379,10 @@ func UpdateAlertNotification(cmd *models.UpdateAlertNotificationCommand) error {
 			return err
 		}
 
+		if current.Id == 0 {
+			return models.ErrAlertNotificationNotFound
+		}
+
 		// check if name exists
 		sameNameQuery := &models.GetAlertNotificationsQuery{OrgId: cmd.OrgId, Name: cmd.Name}
 		if err := getAlertNotificationInternal(sameNameQuery, sess); err != nil {
@@ -433,7 +449,7 @@ func UpdateAlertNotificationWithUid(cmd *models.UpdateAlertNotificationWithUidCo
 	current := getAlertNotificationWithUidQuery.Result
 
 	if current == nil {
-		return fmt.Errorf("Cannot update, alert notification uid %s doesn't exist", cmd.Uid)
+		return models.ErrAlertNotificationNotFound
 	}
 
 	if cmd.NewUid == "" {

pkg/services/sqlstore/alert_notification_test.go

@@ -390,5 +390,87 @@ func TestAlertNotificationSQLAccess(t *testing.T) {
 				So(result, ShouldBeNil)
 			})
 		})
+
+		Convey("Cannot update non-existing Alert Notification", func() {
+			updateCmd := &models.UpdateAlertNotificationCommand{
+				Name:                  "NewName",
+				Type:                  "webhook",
+				OrgId:                 1,
+				SendReminder:          true,
+				DisableResolveMessage: true,
+				Frequency:             "60s",
+				Settings:              simplejson.New(),
+				Id:                    1,
+			}
+			err := UpdateAlertNotification(updateCmd)
+			So(err, ShouldEqual, models.ErrAlertNotificationNotFound)
+
+			Convey("using UID", func() {
+				updateWithUidCmd := &models.UpdateAlertNotificationWithUidCommand{
+					Name:                  "NewName",
+					Type:                  "webhook",
+					OrgId:                 1,
+					SendReminder:          true,
+					DisableResolveMessage: true,
+					Frequency:             "60s",
+					Settings:              simplejson.New(),
+					Uid:                   "uid",
+					NewUid:                "newUid",
+				}
+				err := UpdateAlertNotificationWithUid(updateWithUidCmd)
+				So(err, ShouldEqual, models.ErrAlertNotificationNotFound)
+			})
+		})
+
+		Convey("Can delete Alert Notification", func() {
+			cmd := &models.CreateAlertNotificationCommand{
+				Name:         "ops update",
+				Type:         "email",
+				OrgId:        1,
+				SendReminder: false,
+				Settings:     simplejson.New(),
+			}
+
+			err := CreateAlertNotificationCommand(cmd)
+			So(err, ShouldBeNil)
+
+			deleteCmd := &models.DeleteAlertNotificationCommand{
+				Id:    cmd.Result.Id,
+				OrgId: 1,
+			}
+			err = DeleteAlertNotification(deleteCmd)
+			So(err, ShouldBeNil)
+
+			Convey("using UID", func() {
+				err := CreateAlertNotificationCommand(cmd)
+				So(err, ShouldBeNil)
+
+				deleteWithUidCmd := &models.DeleteAlertNotificationWithUidCommand{
+					Uid:   cmd.Result.Uid,
+					OrgId: 1,
+				}
+				err = DeleteAlertNotificationWithUid(deleteWithUidCmd)
+				So(err, ShouldBeNil)
+				So(deleteWithUidCmd.DeletedAlertNotificationId, ShouldEqual, cmd.Result.Id)
+			})
+		})
+
+		Convey("Cannot delete non-existing Alert Notification", func() {
+			deleteCmd := &models.DeleteAlertNotificationCommand{
+				Id:    1,
+				OrgId: 1,
+			}
+			err := DeleteAlertNotification(deleteCmd)
+			So(err, ShouldEqual, models.ErrAlertNotificationNotFound)
+
+			Convey("using UID", func() {
+				deleteWithUidCmd := &models.DeleteAlertNotificationWithUidCommand{
+					Uid:   "uid",
+					OrgId: 1,
+				}
+				err = DeleteAlertNotificationWithUid(deleteWithUidCmd)
+				So(err, ShouldEqual, models.ErrAlertNotificationNotFound)
+			})
+		})
 	})
 }