Alerting: Add methods for alerts to the forked Alertmanager (#77571)

* Alerting: Add an empty Forked Alertmanager

* Alerting: Add methods for silences to the forked Alertmanager

* check for errors in tests

* make linter happy

* Alerting: Add methods for alerts to the forked Alertmanager

* make linter happy

* separate into both forked AMs

* rename testErr -> expErr

pkg/services/ngalert/remote/forked_alertmanager_test.go

@@ -19,6 +19,7 @@ const (
 
 func TestForkedAlertmanager_ModeRemoteSecondary(t *testing.T) {
 	ctx := context.Background()
+	expErr := errors.New("test error")
 
 	t.Run("CreateSilence", func(tt *testing.T) {
 		// We should create the silence in the internal Alertmanager.
@@ -32,7 +33,6 @@ func TestForkedAlertmanager_ModeRemoteSecondary(t *testing.T) {
 
 		// If there's an error in the internal Alertmanager, it should be returned.
 		internal, _, forked = genTestAlertmanagers(tt, modeRemoteSecondary)
-		expErr := errors.New("test error")
 		internal.EXPECT().CreateSilence(mock.Anything, mock.Anything).Return("", expErr).Once()
 		_, err = forked.CreateSilence(ctx, nil)
 		require.ErrorIs(tt, expErr, err)
@@ -46,7 +46,6 @@ func TestForkedAlertmanager_ModeRemoteSecondary(t *testing.T) {
 
 		// If there's an error in the internal Alertmanager, it should be returned.
 		internal, _, forked = genTestAlertmanagers(tt, modeRemoteSecondary)
-		expErr := errors.New("test error")
 		internal.EXPECT().DeleteSilence(mock.Anything, mock.Anything).Return(expErr).Once()
 		require.ErrorIs(tt, expErr, forked.DeleteSilence(ctx, ""))
 	})
@@ -63,7 +62,6 @@ func TestForkedAlertmanager_ModeRemoteSecondary(t *testing.T) {
 
 		// If there's an error in the internal Alertmanager, it should be returned.
 		internal, _, forked = genTestAlertmanagers(tt, modeRemoteSecondary)
-		expErr := errors.New("test error")
 		internal.EXPECT().GetSilence(mock.Anything, mock.Anything).Return(apimodels.GettableSilence{}, expErr).Once()
 		_, err = forked.GetSilence(ctx, "")
 		require.ErrorIs(tt, expErr, err)
@@ -81,15 +79,95 @@ func TestForkedAlertmanager_ModeRemoteSecondary(t *testing.T) {
 
 		// If there's an error in the internal Alertmanager, it should be returned.
 		internal, _, forked = genTestAlertmanagers(tt, modeRemoteSecondary)
-		expErr := errors.New("test error")
 		internal.EXPECT().ListSilences(mock.Anything, mock.Anything).Return(apimodels.GettableSilences{}, expErr).Once()
 		_, err = forked.ListSilences(ctx, []string{})
 		require.ErrorIs(tt, expErr, err)
 	})
+
+	t.Run("GetAlerts", func(tt *testing.T) {
+		// We should get alerts from the internal Alertmanager.
+		internal, _, forked := genTestAlertmanagers(tt, modeRemoteSecondary)
+
+		expAlerts := apimodels.GettableAlerts{}
+		internal.EXPECT().GetAlerts(
+			mock.Anything,
+			true,
+			true,
+			true,
+			[]string{"test"},
+			"test",
+		).Return(expAlerts, nil).Once()
+
+		alerts, err := forked.GetAlerts(ctx, true, true, true, []string{"test"}, "test")
+		require.NoError(tt, err)
+		require.Equal(tt, expAlerts, alerts)
+
+		// If there's an error in the internal Alertmanager, it should be returned.
+		internal, _, forked = genTestAlertmanagers(tt, modeRemoteSecondary)
+
+		internal.EXPECT().GetAlerts(
+			mock.Anything,
+			true,
+			true,
+			true,
+			[]string{"test"},
+			"test",
+		).Return(apimodels.GettableAlerts{}, expErr).Once()
+
+		_, err = forked.GetAlerts(ctx, true, true, true, []string{"test"}, "test")
+		require.ErrorIs(tt, expErr, err)
+	})
+
+	t.Run("GetAlertGroups", func(tt *testing.T) {
+		// We should get alert groups from the internal Alertmanager.
+		internal, _, forked := genTestAlertmanagers(tt, modeRemoteSecondary)
+
+		expAlertGroups := apimodels.AlertGroups{}
+		internal.EXPECT().GetAlertGroups(
+			mock.Anything,
+			true,
+			true,
+			true,
+			[]string{"test"},
+			"test",
+		).Return(expAlertGroups, nil).Once()
+
+		alertGroups, err := forked.GetAlertGroups(ctx, true, true, true, []string{"test"}, "test")
+		require.NoError(tt, err)
+		require.Equal(tt, expAlertGroups, alertGroups)
+
+		// If there's an error in the internal Alertmanager, it should be returned.
+		internal, _, forked = genTestAlertmanagers(tt, modeRemoteSecondary)
+
+		internal.EXPECT().GetAlertGroups(
+			mock.Anything,
+			true,
+			true,
+			true,
+			[]string{"test"},
+			"test",
+		).Return(apimodels.AlertGroups{}, expErr).Once()
+
+		_, err = forked.GetAlertGroups(ctx, true, true, true, []string{"test"}, "test")
+		require.ErrorIs(tt, expErr, err)
+	})
+
+	t.Run("PutAlerts", func(tt *testing.T) {
+		// We should send alerts to the internal Alertmanager only.
+		internal, _, forked := genTestAlertmanagers(tt, modeRemoteSecondary)
+		internal.EXPECT().PutAlerts(mock.Anything, mock.Anything).Return(nil).Once()
+		require.NoError(tt, forked.PutAlerts(ctx, apimodels.PostableAlerts{}))
+
+		// If there's an error in the internal Alertmanager, it should be returned.
+		internal, _, forked = genTestAlertmanagers(tt, modeRemoteSecondary)
+		internal.EXPECT().PutAlerts(mock.Anything, mock.Anything).Return(expErr).Once()
+		require.ErrorIs(tt, expErr, forked.PutAlerts(ctx, apimodels.PostableAlerts{}))
+	})
 }
 
 func TestForkedAlertmanager_ModeRemotePrimary(t *testing.T) {
 	ctx := context.Background()
+	expErr := errors.New("test error")
 
 	t.Run("CreateSilence", func(tt *testing.T) {
 		// We should create the silence in the remote Alertmanager.
@@ -102,7 +180,6 @@ func TestForkedAlertmanager_ModeRemotePrimary(t *testing.T) {
 		require.Equal(tt, expID, id)
 
 		// If there's an error in the remote Alertmanager, the error should be returned.
-		expErr := errors.New("test error")
 		remote.EXPECT().CreateSilence(mock.Anything, mock.Anything).Return("", expErr).Maybe()
 		_, err = forked.CreateSilence(ctx, nil)
 		require.ErrorIs(tt, expErr, err)
@@ -116,7 +193,6 @@ func TestForkedAlertmanager_ModeRemotePrimary(t *testing.T) {
 
 		// If there's an error in the remote Alertmanager, the error should be returned.
 		_, remote, forked = genTestAlertmanagers(tt, modeRemotePrimary)
-		expErr := errors.New("test error")
 		remote.EXPECT().DeleteSilence(mock.Anything, mock.Anything).Return(expErr).Maybe()
 		require.ErrorIs(tt, expErr, forked.DeleteSilence(ctx, ""))
 	})
@@ -132,7 +208,6 @@ func TestForkedAlertmanager_ModeRemotePrimary(t *testing.T) {
 
 		// If there's an error in the remote Alertmanager, the error should be returned.
 		_, remote, forked = genTestAlertmanagers(tt, modeRemotePrimary)
-		expErr := errors.New("test error")
 		remote.EXPECT().GetSilence(mock.Anything, mock.Anything).Return(apimodels.GettableSilence{}, expErr).Once()
 		_, err = forked.GetSilence(ctx, "")
 		require.ErrorIs(tt, expErr, err)
@@ -149,11 +224,90 @@ func TestForkedAlertmanager_ModeRemotePrimary(t *testing.T) {
 
 		// If there's an error in the remote Alertmanager, the error should be returned.
 		_, remote, forked = genTestAlertmanagers(tt, modeRemotePrimary)
-		expErr := errors.New("test error")
 		remote.EXPECT().ListSilences(mock.Anything, mock.Anything).Return(apimodels.GettableSilences{}, expErr).Once()
 		_, err = forked.ListSilences(ctx, []string{})
 		require.ErrorIs(tt, expErr, err)
 	})
+
+	t.Run("GetAlerts", func(tt *testing.T) {
+		// We should get alerts from the remote Alertmanager.
+		_, remote, forked := genTestAlertmanagers(tt, modeRemotePrimary)
+
+		expAlerts := apimodels.GettableAlerts{}
+		remote.EXPECT().GetAlerts(
+			mock.Anything,
+			true,
+			true,
+			true,
+			[]string{"test"},
+			"test",
+		).Return(expAlerts, nil).Once()
+
+		alerts, err := forked.GetAlerts(ctx, true, true, true, []string{"test"}, "test")
+		require.NoError(tt, err)
+		require.Equal(tt, expAlerts, alerts)
+
+		// If there's an error in the remote Alertmanager, it should be returned.
+		_, remote, forked = genTestAlertmanagers(tt, modeRemotePrimary)
+
+		remote.EXPECT().GetAlerts(
+			mock.Anything,
+			true,
+			true,
+			true,
+			[]string{"test"},
+			"test",
+		).Return(apimodels.GettableAlerts{}, expErr).Once()
+
+		_, err = forked.GetAlerts(ctx, true, true, true, []string{"test"}, "test")
+		require.ErrorIs(tt, expErr, err)
+	})
+
+	t.Run("GetAlertGroups", func(tt *testing.T) {
+		// We should get alert groups from the remote Alertmanager.
+		_, remote, forked := genTestAlertmanagers(tt, modeRemotePrimary)
+
+		expAlertGroups := apimodels.AlertGroups{}
+		remote.EXPECT().GetAlertGroups(
+			mock.Anything,
+			true,
+			true,
+			true,
+			[]string{"test"},
+			"test",
+		).Return(expAlertGroups, nil).Once()
+
+		alertGroups, err := forked.GetAlertGroups(ctx, true, true, true, []string{"test"}, "test")
+		require.NoError(tt, err)
+		require.Equal(tt, expAlertGroups, alertGroups)
+
+		// If there's an error in the remote Alertmanager, it should be returned.
+		_, remote, forked = genTestAlertmanagers(tt, modeRemotePrimary)
+
+		remote.EXPECT().GetAlertGroups(
+			mock.Anything,
+			true,
+			true,
+			true,
+			[]string{"test"},
+			"test",
+		).Return(apimodels.AlertGroups{}, expErr).Once()
+
+		_, err = forked.GetAlertGroups(ctx, true, true, true, []string{"test"}, "test")
+		require.ErrorIs(tt, expErr, err)
+	})
+
+	t.Run("PutAlerts", func(tt *testing.T) {
+		// We should send alerts to the remote Alertmanager only.
+		_, remote, forked := genTestAlertmanagers(tt, modeRemotePrimary)
+		remote.EXPECT().PutAlerts(mock.Anything, mock.Anything).Return(nil).Once()
+		require.NoError(tt, forked.PutAlerts(ctx, apimodels.PostableAlerts{}))
+
+		// If there's an error in the remote Alertmanager, it should be returned.
+		_, remote, forked = genTestAlertmanagers(tt, modeRemotePrimary)
+		remote.EXPECT().PutAlerts(mock.Anything, mock.Anything).Return(expErr).Once()
+		require.ErrorIs(tt, expErr, forked.PutAlerts(ctx, apimodels.PostableAlerts{}))
+	})
 }
 func genTestAlertmanagers(t *testing.T, mode int) (*alertmanager_mock.AlertmanagerMock, *alertmanager_mock.AlertmanagerMock, notifier.Alertmanager) {
 	t.Helper()

pkg/services/ngalert/remote/remote_primary_forked_alertmanager.go

@@ -53,15 +53,15 @@ func (fam *RemotePrimaryForkedAlertmanager) ListSilences(ctx context.Context, fi
 }
 
 func (fam *RemotePrimaryForkedAlertmanager) GetAlerts(ctx context.Context, active, silenced, inhibited bool, filter []string, receiver string) (apimodels.GettableAlerts, error) {
-	return apimodels.GettableAlerts{}, nil
+	return fam.remote.GetAlerts(ctx, active, silenced, inhibited, filter, receiver)
 }
 
 func (fam *RemotePrimaryForkedAlertmanager) GetAlertGroups(ctx context.Context, active, silenced, inhibited bool, filter []string, receiver string) (apimodels.AlertGroups, error) {
-	return apimodels.AlertGroups{}, nil
+	return fam.remote.GetAlertGroups(ctx, active, silenced, inhibited, filter, receiver)
 }
 
 func (fam *RemotePrimaryForkedAlertmanager) PutAlerts(ctx context.Context, alerts apimodels.PostableAlerts) error {
-	return nil
+	return fam.remote.PutAlerts(ctx, alerts)
 }
 
 func (fam *RemotePrimaryForkedAlertmanager) GetReceivers(ctx context.Context) ([]apimodels.Receiver, error) {

pkg/services/ngalert/remote/remote_secondary_forked_alertmanager.go

@@ -53,15 +53,15 @@ func (fam *RemoteSecondaryForkedAlertmanager) ListSilences(ctx context.Context,
 }
 
 func (fam *RemoteSecondaryForkedAlertmanager) GetAlerts(ctx context.Context, active, silenced, inhibited bool, filter []string, receiver string) (apimodels.GettableAlerts, error) {
-	return apimodels.GettableAlerts{}, nil
+	return fam.internal.GetAlerts(ctx, active, silenced, inhibited, filter, receiver)
 }
 
 func (fam *RemoteSecondaryForkedAlertmanager) GetAlertGroups(ctx context.Context, active, silenced, inhibited bool, filter []string, receiver string) (apimodels.AlertGroups, error) {
-	return apimodels.AlertGroups{}, nil
+	return fam.internal.GetAlertGroups(ctx, active, silenced, inhibited, filter, receiver)
 }
 
 func (fam *RemoteSecondaryForkedAlertmanager) PutAlerts(ctx context.Context, alerts apimodels.PostableAlerts) error {
-	return nil
+	return fam.internal.PutAlerts(ctx, alerts)
 }
 
 func (fam *RemoteSecondaryForkedAlertmanager) GetReceivers(ctx context.Context) ([]apimodels.Receiver, error) {