type errors

Author: titolins

notify/stages/sync_flush_stage.go

@@ -22,6 +22,13 @@ const (
 	SyncFlushActionSync     SyncFlushAction = "sync"
 )
 
+var (
+	ErrMissingGroupKey           = errors.New("groupKey missing")
+	ErrMissingNow                = errors.New("now missing")
+	ErrMissingGroupInterval      = errors.New("groupInterval missing")
+	ErrUnexpectedEntryResultSize = errors.New("unexpected entry result size")
+)
+
 // SyncFlushStage delays the notification pipeline execution to sync flushes between multiple instances.
 type SyncFlushStage struct {
 	nflog  notify.NotificationLog
@@ -69,18 +76,18 @@ func (sfs *SyncFlushStage) calculateSyncWaitTime(curPipelineTime, prevPipelineTi
 func (sfs *SyncFlushStage) Exec(ctx context.Context, l log.Logger, alerts ...*types.Alert) (context.Context, []*types.Alert, error) {
 	gkey, ok := notify.GroupKey(ctx)
 	if !ok {
-		return ctx, nil, errors.New("group key missing")
+		return ctx, nil, ErrMissingGroupKey
 	}
 
 	// get the tick time from the context.
 	curPipelineTime, ok := notify.Now(ctx)
 	if !ok {
-		return ctx, nil, errors.New("now missing")
+		return ctx, nil, ErrMissingNow
 	}
 
 	groupInterval, ok := notify.GroupInterval(ctx)
 	if !ok {
-		return ctx, nil, errors.New("groupWait missing")
+		return ctx, nil, ErrMissingGroupInterval
 	}
 
 	entries, err := sfs.nflog.Query(nflog.QGroupKey(gkey), nflog.QReceiver(sfs.recv))
@@ -96,7 +103,7 @@ func (sfs *SyncFlushStage) Exec(ctx context.Context, l log.Logger, alerts ...*ty
 	case 1:
 		entry = entries[0]
 	default:
-		return ctx, nil, fmt.Errorf("unexpected entry result size %d", len(entries))
+		return ctx, nil, fmt.Errorf("%w: %d", ErrUnexpectedEntryResultSize, len(entries))
 	}
 
 	// calculate next flush time based on last entry on notification log

notify/stages/sync_flush_stage_test.go

@@ -79,38 +79,37 @@ func TestSyncFlushStageExec(t *testing.T) {
 		skipGroupKey   bool
 		skipNow        bool
 		skipGroupWait  bool
-		expectedErr    bool
+		expectedErr    error
 	}{
 		{
 			name:         "no entries",
 			sync:         true,
 			entries:      []*nflogpb.Entry{},
 			pipelineTime: now,
-			expectedErr:  false,
 		},
 		{
 			name:         "missing group key",
 			sync:         true,
 			entries:      []*nflogpb.Entry{},
 			pipelineTime: now,
 			skipGroupKey: true,
-			expectedErr:  true,
+			expectedErr:  ErrMissingGroupKey,
 		},
 		{
 			name:         "missing now",
 			sync:         true,
 			entries:      []*nflogpb.Entry{},
 			pipelineTime: now,
 			skipNow:      true,
-			expectedErr:  true,
+			expectedErr:  ErrMissingNow,
 		},
 		{
 			name:          "missing group wait",
 			sync:          true,
 			entries:       []*nflogpb.Entry{},
 			pipelineTime:  now,
 			skipGroupWait: true,
-			expectedErr:   true,
+			expectedErr:   ErrMissingGroupInterval,
 		},
 		{
 			name: "entry exists but no wait needed",
@@ -122,7 +121,6 @@ func TestSyncFlushStageExec(t *testing.T) {
 				},
 			},
 			pipelineTime: now,
-			expectedErr:  false,
 		},
 		{
 			name: "entry exists and wait would be needed",
@@ -134,7 +132,6 @@ func TestSyncFlushStageExec(t *testing.T) {
 				},
 			},
 			pipelineTime: now,
-			expectedErr:  false,
 		},
 		{
 			name: "sync disabled",
@@ -146,7 +143,6 @@ func TestSyncFlushStageExec(t *testing.T) {
 				},
 			},
 			pipelineTime: now,
-			expectedErr:  false,
 		},
 		{
 			name: "context timeout",
@@ -159,7 +155,7 @@ func TestSyncFlushStageExec(t *testing.T) {
 			},
 			pipelineTime:   now,
 			contextTimeout: 50 * time.Millisecond,
-			expectedErr:    true,
+			expectedErr:    context.DeadlineExceeded,
 		},
 		{
 			name: "multiple entries error",
@@ -175,7 +171,7 @@ func TestSyncFlushStageExec(t *testing.T) {
 				},
 			},
 			pipelineTime: now,
-			expectedErr:  true,
+			expectedErr:  ErrUnexpectedEntryResultSize,
 		},
 	}
 
@@ -212,12 +208,8 @@ func TestSyncFlushStageExec(t *testing.T) {
 			alerts := []*types.Alert{{}, {}}
 			_, gotAlerts, err := stage.Exec(ctx, log.NewNopLogger(), alerts...)
 
-			if tc.expectedErr {
-				assert.Error(t, err)
-			} else {
-				assert.NoError(t, err)
-				assert.Equal(t, alerts, gotAlerts)
-			}
+			assert.Equal(t, alerts, gotAlerts)
+			assert.ErrorIs(t, err, tc.expectedErr)
 		})
 	}
 }
@@ -264,3 +256,4 @@ func TestNewSyncFlushStage(t *testing.T) {
 		})
 	}
 }
+