test: increase coverage

Author: maximiliantech

pkg/smartrequeue/entry.go

@@ -24,7 +24,6 @@ func newEntry(s *Store) *Entry {
 // so that the controller-runtime can handle the exponential backoff for errors.
 func (e *Entry) Error(err error) (ctrl.Result, error) {
 	e.nextDuration = e.store.minInterval
-	e.setNext()
 	return ctrl.Result{}, err
 }
 

pkg/smartrequeue/entry_test.go

@@ -1,36 +1,125 @@
 package smartrequeue
 
 import (
+	"errors"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	ctrl "sigs.k8s.io/controller-runtime"
 )
 
-func Test_Entry(t *testing.T) {
-	entry := newEntry(NewStore(time.Second, time.Minute, 2))
+// Helper function to get requeue duration from Result
+func getRequeueAfter(res ctrl.Result, _ error) time.Duration {
+	return res.RequeueAfter.Round(time.Second)
+}
+
+func TestEntry_Stable(t *testing.T) {
+	// Setup
+	store := NewStore(time.Second, time.Minute, 2)
+	entry := newEntry(store)
+
+	// Test the exponential backoff behavior
+	t.Run("exponential backoff sequence", func(t *testing.T) {
+		expectedDurations := []time.Duration{
+			1 * time.Second,
+			2 * time.Second,
+			4 * time.Second,
+			8 * time.Second,
+			16 * time.Second,
+			32 * time.Second,
+			60 * time.Second, // Capped at maxInterval
+			60 * time.Second, // Still capped
+		}
 
-	assert.Equal(t, 1*time.Second, getRequeueAfter(entry.Stable()))
-	assert.Equal(t, 2*time.Second, getRequeueAfter(entry.Stable()))
-	assert.Equal(t, 4*time.Second, getRequeueAfter(entry.Stable()))
-	assert.Equal(t, 8*time.Second, getRequeueAfter(entry.Stable()))
-	assert.Equal(t, 16*time.Second, getRequeueAfter(entry.Stable()))
-	assert.Equal(t, 32*time.Second, getRequeueAfter(entry.Stable()))
-	assert.Equal(t, 60*time.Second, getRequeueAfter(entry.Stable()))
-	assert.Equal(t, 60*time.Second, getRequeueAfter(entry.Stable()))
+		for i, expected := range expectedDurations {
+			result, err := entry.Stable()
+			require.NoError(t, err)
+			assert.Equal(t, expected, getRequeueAfter(result, err), "Iteration %d should have correct duration", i)
+		}
+	})
+}
+
+func TestEntry_Progressing(t *testing.T) {
+	// Setup
+	minInterval := time.Second
+	maxInterval := time.Minute
+	store := NewStore(minInterval, maxInterval, 2)
+	entry := newEntry(store)
+
+	// Ensure state is not at minimum
+	_, _ = entry.Stable()
+	_, _ = entry.Stable()
 
-	assert.Equal(t, 1*time.Second, getRequeueAfter(entry.Progressing()))
-	assert.Equal(t, 1*time.Second, getRequeueAfter(entry.Progressing()))
+	// Test progressing resets duration to minimum
+	t.Run("resets to minimum interval", func(t *testing.T) {
+		result, err := entry.Progressing()
+		require.NoError(t, err)
+		assert.Equal(t, minInterval, getRequeueAfter(result, err))
 
-	assert.Equal(t, 2*time.Second, getRequeueAfter(entry.Stable()))
-	assert.Equal(t, 4*time.Second, getRequeueAfter(entry.Stable()))
+		// Second call should also return min interval with small increment
+		result, err = entry.Progressing()
+		require.NoError(t, err)
+		assert.Equal(t, minInterval, getRequeueAfter(result, err))
+	})
 
-	assert.Equal(t, 0*time.Second, getRequeueAfter(entry.Error(assert.AnError)))
-	assert.Equal(t, 2*time.Second, getRequeueAfter(entry.Stable()))
-	assert.Equal(t, 4*time.Second, getRequeueAfter(entry.Stable()))
+	// After progressing, Stable should restart exponential backoff
+	t.Run("stable continues from minimum", func(t *testing.T) {
+		result, err := entry.Stable()
+		require.NoError(t, err)
+		assert.Equal(t, 2*time.Second, getRequeueAfter(result, err))
+
+		result, err = entry.Stable()
+		require.NoError(t, err)
+		assert.Equal(t, 4*time.Second, getRequeueAfter(result, err))
+	})
 }
 
-func getRequeueAfter(res ctrl.Result, _ error) time.Duration {
-	return res.RequeueAfter.Round(time.Second)
+func TestEntry_Error(t *testing.T) {
+	// Setup
+	store := NewStore(time.Second, time.Minute, 2)
+	entry := newEntry(store)
+	testErr := errors.New("test error")
+
+	// Ensure state is not at minimum
+	_, _ = entry.Stable()
+	_, _ = entry.Stable()
+
+	// Test error handling
+	t.Run("returns error and resets backoff", func(t *testing.T) {
+		result, err := entry.Error(testErr)
+		assert.Equal(t, testErr, err, "Should return the passed error")
+		assert.Equal(t, 0*time.Second, getRequeueAfter(result, err), "Should have zero requeue time")
+	})
+
+	// After error, stable should continue from minimum
+	t.Run("stable continues properly after error", func(t *testing.T) {
+		result, err := entry.Stable()
+		require.NoError(t, err)
+		assert.Equal(t, time.Second, getRequeueAfter(result, err))
+
+		result, err = entry.Stable()
+		require.NoError(t, err)
+		assert.Equal(t, 2*time.Second, getRequeueAfter(result, err))
+	})
+}
+
+func TestEntry_Never(t *testing.T) {
+	// Setup with store spy to verify deletion
+	store := NewStore(time.Second, time.Minute, 2)
+	entry := newEntry(store)
+
+	// Call some methods first to ensure we have state
+	_, _ = entry.Stable()
+
+	// Test Never
+	t.Run("returns empty result and no error", func(t *testing.T) {
+		result, err := entry.Never()
+		assert.NoError(t, err)
+		assert.Equal(t, 0*time.Second, getRequeueAfter(result, err))
+	})
+
+	// Therotically, we should verify that the entry is deleted from the store.
+	// Since we don't have direct access to store internals here, this is not possible.
 }