test(consensus): integration-test IsBehind across peer topologies

Covers the live wiring that the pure-helper tests don't: IsBehind driving
a real (non-started) Switch's peer set through collectPeerHeights into
evaluateBehind, plus the sole-validator and debounce paths, end to end.

Builds a Reactor with mock peers at chosen heights, a round state at a
chosen height, and catchUpDebounce=0 so the result is the raw decision
with no timing. Cases mirror the operational topologies:
- majority of peers ahead -> behind (the partition / fell-behind case),
- synced multi-peer network -> not behind (no false positive on a healthy
  multi-node network),
- lone peer ahead -> not behind (cannot corroborate),
- no peers and not the sole validator -> behind (isolated node),
- no peers but the sole validator -> not behind (finalizes alone).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: pratikspatil024

consensus/reactor_catchup_test.go

@@ -5,7 +5,10 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
+	cfg "github.com/cometbft/cometbft/config"
+	cstypes "github.com/cometbft/cometbft/consensus/types"
 	"github.com/cometbft/cometbft/crypto"
 	"github.com/cometbft/cometbft/p2p"
 	p2pmock "github.com/cometbft/cometbft/p2p/mock"
@@ -114,6 +117,56 @@ func TestReactorCatchupConfig(t *testing.T) {
 	assert.Equal(t, 3*time.Second, conR.catchUpDebounce)
 }
 
+// newCatchupReactor wires a Reactor with a non-started Switch carrying mock peers
+// at the given heights, a round state at myHeight, and (optionally) a single-validator
+// set that this node belongs to. catchUpDebounce is 0 so IsBehind reflects the raw
+// decision immediately, keeping the test free of timing.
+func newCatchupReactor(t *testing.T, myHeight int64, sole bool, peerHeights ...int64) *Reactor {
+	t.Helper()
+	cs := &State{}
+	if sole {
+		val, _ := types.RandValidator(false, 10)
+		cs.Validators = types.NewValidatorSet([]*types.Validator{val})
+		cs.privValidatorPubKey = val.PubKey
+	}
+	conR := &Reactor{
+		conS:                cs,
+		rs:                  &cstypes.RoundState{Height: myHeight},
+		catchUpLagThreshold: 5,
+		catchUpDebounce:     0,
+	}
+	conR.BaseReactor = *p2p.NewBaseReactor("Consensus", conR)
+
+	sw := p2p.NewSwitch(cfg.DefaultP2PConfig(), nil)
+	peerSet := sw.Peers().(*p2p.PeerSet)
+	for _, h := range peerHeights {
+		require.NoError(t, peerSet.Add(peerWithHeight(h)))
+	}
+	conR.SetSwitch(sw)
+	return conR
+}
+
+// TestIsBehindIntegration exercises the full IsBehind path (Switch peers ->
+// collectPeerHeights -> evaluateBehind, plus the sole-validator and debounce
+// wiring) rather than the pure decision helpers in isolation.
+func TestIsBehindIntegration(t *testing.T) {
+	t.Run("majority of peers ahead reports behind", func(t *testing.T) {
+		assert.True(t, newCatchupReactor(t, 100, false, 110, 110, 110).IsBehind())
+	})
+	t.Run("synced multi-peer network is not behind", func(t *testing.T) {
+		assert.False(t, newCatchupReactor(t, 100, false, 100, 100, 100).IsBehind())
+	})
+	t.Run("lone peer ahead cannot corroborate", func(t *testing.T) {
+		assert.False(t, newCatchupReactor(t, 100, false, 110).IsBehind())
+	})
+	t.Run("no peers and not sole validator is behind", func(t *testing.T) {
+		assert.True(t, newCatchupReactor(t, 100, false).IsBehind())
+	})
+	t.Run("no peers but sole validator is not behind", func(t *testing.T) {
+		assert.False(t, newCatchupReactor(t, 100, true).IsBehind())
+	})
+}
+
 func TestApplyDebounce(t *testing.T) {
 	debounce := 10 * time.Second
 	t0 := time.Now()