Support lazy setup in readiness endpoint

Author: alpe

pkg/rpc/server/http.go

@@ -90,9 +90,13 @@ func RegisterCustomHTTPEndpoints(mux *http.ServeMux, s store.Store, pm p2p.P2PRP
 		}
 
 		if cfg.Node.Aggregator {
+			var maxAllowedDelay time.Duration
+			if cfg.Node.LazyMode {
+				maxAllowedDelay = 2 * cfg.Node.LazyBlockInterval.Duration
+			} else {
+				maxAllowedDelay = 5 * cfg.Node.BlockTime.Duration
+			}
 			timeSinceLastBlock := time.Since(state.LastBlockTime)
-			maxAllowedDelay := 5 * cfg.Node.BlockTime.Duration
-
 			if timeSinceLastBlock > maxAllowedDelay {
 				http.Error(w, "UNREADY: aggregator not producing blocks at expected rate", http.StatusServiceUnavailable)
 				return

pkg/rpc/server/http_test.go

@@ -5,12 +5,15 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"testing"
+	"time"
 
 	"github.com/evstack/ev-node/pkg/config"
 	"github.com/evstack/ev-node/test/mocks"
+	"github.com/evstack/ev-node/types"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
 )
 
 func TestRegisterCustomHTTPEndpoints(t *testing.T) {
@@ -38,3 +41,95 @@ func TestRegisterCustomHTTPEndpoints(t *testing.T) {
 
 	mockStore.AssertExpectations(t)
 }
+
+func TestHealthReady_aggregatorBlockDelay(t *testing.T) {
+	ctx := t.Context()
+	logger := zerolog.Nop()
+
+	type spec struct {
+		name          string
+		lazy          bool
+		blockTime     time.Duration
+		lazyInterval  time.Duration
+		delay         time.Duration
+		expStatusCode int
+		expBody       string
+	}
+
+	specs := map[string]spec{
+		"aggregator within non-lazy threshold": {
+			lazy:          false,
+			blockTime:     200 * time.Millisecond,
+			lazyInterval:  0,
+			delay:         800 * time.Millisecond, // 5x blockTime = 1s, so 0.8s is OK
+			expStatusCode: http.StatusOK,
+			expBody:       "READY\n",
+		},
+		"aggregator exceeds non-lazy threshold": {
+			lazy:          false,
+			blockTime:     200 * time.Millisecond,
+			lazyInterval:  0,
+			delay:         1500 * time.Millisecond, // > 1s threshold
+			expStatusCode: http.StatusServiceUnavailable,
+			expBody:       "UNREADY: aggregator not producing blocks at expected rate\n",
+		},
+		"aggregator within lazy threshold": {
+			lazy:          true,
+			blockTime:     0,
+			lazyInterval:  300 * time.Millisecond,
+			delay:         500 * time.Millisecond, // 2x lazyInterval = 600ms, so 0.5s is OK
+			expStatusCode: http.StatusOK,
+			expBody:       "READY\n",
+		},
+		"aggregator exceeds lazy threshold": {
+			lazy:          true,
+			blockTime:     0,
+			lazyInterval:  300 * time.Millisecond,
+			delay:         800 * time.Millisecond, // > 600ms threshold
+			expStatusCode: http.StatusServiceUnavailable,
+			expBody:       "UNREADY: aggregator not producing blocks at expected rate\n",
+		},
+	}
+
+	for name, tc := range specs {
+		t.Run(name, func(t *testing.T) {
+			mux := http.NewServeMux()
+
+			cfg := config.DefaultConfig()
+			cfg.Node.Aggregator = true
+			if tc.blockTime > 0 {
+				cfg.Node.BlockTime = config.DurationWrapper{Duration: tc.blockTime}
+			}
+			cfg.Node.LazyMode = tc.lazy
+			if tc.lazy {
+				cfg.Node.LazyBlockInterval = config.DurationWrapper{Duration: tc.lazyInterval}
+			}
+
+			mockStore := mocks.NewMockStore(t)
+			state := types.State{
+				LastBlockHeight: 10,
+				LastBlockTime:   time.Now().Add(-tc.delay),
+			}
+			mockStore.On("GetState", mock.Anything).Return(state, nil)
+
+			bestKnownHeightProvider := func() uint64 { return state.LastBlockHeight }
+
+			RegisterCustomHTTPEndpoints(mux, mockStore, nil, cfg, bestKnownHeightProvider, logger)
+
+			ts := httptest.NewServer(mux)
+			t.Cleanup(ts.Close)
+
+			req, err := http.NewRequestWithContext(ctx, http.MethodGet, ts.URL+"/health/ready", nil)
+			require.NoError(t, err)
+			resp, err := http.DefaultClient.Do(req)
+			require.NoError(t, err)
+			t.Cleanup(func() { _ = resp.Body.Close() })
+
+			body, err := io.ReadAll(resp.Body)
+			require.NoError(t, err)
+
+			assert.Equal(t, tc.expStatusCode, resp.StatusCode)
+			assert.Equal(t, tc.expBody, string(body))
+		})
+	}
+}