test: add tests

Author: julienrbrt

block/internal/executing/executor_logic_test.go

@@ -3,6 +3,7 @@ package executing
 import (
 	"context"
 	crand "crypto/rand"
+	"errors"
 	"testing"
 	"time"
 
@@ -207,3 +208,114 @@ func TestPendingLimit_SkipsProduction(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, h1, h2, "height should not change when production is skipped")
 }
+
+func TestExecutor_executeTxsWithRetry(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name          string
+		setupMock     func(*testmocks.MockExecutor)
+		expectSuccess bool
+		expectHash    []byte
+		expectError   string
+	}{
+		{
+			name: "success on first attempt",
+			setupMock: func(exec *testmocks.MockExecutor) {
+				exec.On("ExecuteTxs", mock.Anything, mock.Anything, uint64(100), mock.Anything, mock.Anything).
+					Return([]byte("new-hash"), uint64(0), nil).Once()
+			},
+			expectSuccess: true,
+			expectHash:    []byte("new-hash"),
+		},
+		{
+			name: "success on second attempt",
+			setupMock: func(exec *testmocks.MockExecutor) {
+				exec.On("ExecuteTxs", mock.Anything, mock.Anything, uint64(100), mock.Anything, mock.Anything).
+					Return([]byte(nil), uint64(0), errors.New("temporary failure")).Once()
+				exec.On("ExecuteTxs", mock.Anything, mock.Anything, uint64(100), mock.Anything, mock.Anything).
+					Return([]byte("new-hash"), uint64(0), nil).Once()
+			},
+			expectSuccess: true,
+			expectHash:    []byte("new-hash"),
+		},
+		{
+			name: "success on third attempt",
+			setupMock: func(exec *testmocks.MockExecutor) {
+				exec.On("ExecuteTxs", mock.Anything, mock.Anything, uint64(100), mock.Anything, mock.Anything).
+					Return([]byte(nil), uint64(0), errors.New("temporary failure")).Times(2)
+				exec.On("ExecuteTxs", mock.Anything, mock.Anything, uint64(100), mock.Anything, mock.Anything).
+					Return([]byte("new-hash"), uint64(0), nil).Once()
+			},
+			expectSuccess: true,
+			expectHash:    []byte("new-hash"),
+		},
+		{
+			name: "failure after max retries",
+			setupMock: func(exec *testmocks.MockExecutor) {
+				exec.On("ExecuteTxs", mock.Anything, mock.Anything, uint64(100), mock.Anything, mock.Anything).
+					Return([]byte(nil), uint64(0), errors.New("persistent failure")).Times(common.MaxRetriesBeforeHalt)
+			},
+			expectSuccess: false,
+			expectError:   "failed to execute transactions",
+		},
+		{
+			name: "context cancelled during retry",
+			setupMock: func(exec *testmocks.MockExecutor) {
+				exec.On("ExecuteTxs", mock.Anything, mock.Anything, uint64(100), mock.Anything, mock.Anything).
+					Return([]byte(nil), uint64(0), errors.New("temporary failure")).Once()
+			},
+			expectSuccess: false,
+			expectError:   "context cancelled during retry",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			ctx := context.Background()
+			execCtx := ctx
+
+			// For context cancellation test, create a cancellable context
+			if tt.name == "context cancelled during retry" {
+				var cancel context.CancelFunc
+				execCtx, cancel = context.WithCancel(ctx)
+				// Cancel context after first failure to simulate cancellation during retry
+				go func() {
+					time.Sleep(100 * time.Millisecond)
+					cancel()
+				}()
+			}
+
+			mockExec := testmocks.NewMockExecutor(t)
+			tt.setupMock(mockExec)
+
+			e := &Executor{
+				exec:   mockExec,
+				ctx:    execCtx,
+				logger: zerolog.Nop(),
+			}
+
+			rawTxs := [][]byte{[]byte("tx1"), []byte("tx2")}
+			header := types.Header{
+				BaseHeader: types.BaseHeader{Height: 100, Time: uint64(time.Now().UnixNano())},
+			}
+			currentState := types.State{AppHash: []byte("current-hash")}
+
+			result, err := e.executeTxsWithRetry(ctx, rawTxs, header, currentState)
+
+			if tt.expectSuccess {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expectHash, result)
+			} else {
+				require.Error(t, err)
+				if tt.expectError != "" {
+					assert.Contains(t, err.Error(), tt.expectError)
+				}
+			}
+
+			mockExec.AssertExpectations(t)
+		})
+	}
+}