test: improve patch coverage for raft shutdown and resign paths

Add unit tests for lines flagged by Codecov:
- boltTxClosedFilter.Write: filter drops "tx closed", forwards others
- buildRaftConfig: ElectionTimeout > 0 applied, zero uses default
- FullNode.ResignLeader: nil raftNode no-op; non-leader raftNode no-op
- Syncer.Stop: raftRetriever.Stop is called when raftRetriever is set
- Syncer.RecoverFromRaft: GetHeader failure when local state is ahead of
  stale raft snapshot returns "cannot verify hash" error

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: auricom

block/internal/syncing/syncer_test.go

@@ -532,6 +532,59 @@ func TestSyncer_RecoverFromRaft_LocalAheadOfStaleSnapshot(t *testing.T) {
 		require.Error(t, err)
 		require.ErrorContains(t, err, "diverged from raft")
 	})
+
+	t.Run("get header fails returns error", func(t *testing.T) {
+		// lastState is at height 2; raft snapshot at height 0.
+		// No block is stored at height 0, so GetHeader fails.
+		err := s.RecoverFromRaft(t.Context(), &raft.RaftBlockState{
+			Height: 0,
+			Hash:   make([]byte, 32),
+			Header: headerBz1,
+			Data:   dataBz1,
+		})
+		require.Error(t, err)
+		require.ErrorContains(t, err, "cannot verify hash")
+	})
+}
+
+func TestSyncer_Stop_CallsRaftRetrieverStop(t *testing.T) {
+	ds := dssync.MutexWrap(datastore.NewMapDatastore())
+	st := store.New(ds)
+
+	cm, err := cache.NewManager(config.DefaultConfig(), st, zerolog.Nop())
+	require.NoError(t, err)
+
+	raftNode := &stubRaftNode{}
+	s := NewSyncer(
+		st,
+		nil,
+		nil,
+		cm,
+		common.NopMetrics(),
+		config.DefaultConfig(),
+		genesis.Genesis{},
+		nil,
+		nil,
+		zerolog.Nop(),
+		common.DefaultBlockOptions(),
+		make(chan error, 1),
+		raftNode,
+	)
+
+	require.NotNil(t, s.raftRetriever, "raftRetriever should be set when raftNode is provided")
+
+	// Manually set cancel so Stop() doesn't bail out early (simulates having been started).
+	ctx, cancel := context.WithCancel(t.Context())
+	s.ctx = ctx
+	s.cancel = cancel
+
+	require.NoError(t, s.Stop(t.Context()))
+
+	// raftRetriever.Stop clears the apply callback (sets it to nil).
+	// The stub records each SetApplyCallback call; the last one should be nil.
+	callbacks := raftNode.recordedCallbacks()
+	require.NotEmpty(t, callbacks, "expected at least one callback registration")
+	assert.Nil(t, callbacks[len(callbacks)-1], "last callback should be nil after Stop")
 }
 
 func TestSyncer_processPendingEvents(t *testing.T) {

node/full_node_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	raftpkg "github.com/evstack/ev-node/pkg/raft"
 	"github.com/evstack/ev-node/pkg/service"
 )
 
@@ -82,3 +83,15 @@ func TestStartInstrumentationServer(t *testing.T) {
 		assert.NoError(err, "Pprof server shutdown should not return error")
 	}
 }
+
+func TestFullNode_ResignLeader_NilRaftNode(t *testing.T) {
+	n := &FullNode{} // raftNode is nil
+	assert.NoError(t, n.ResignLeader())
+}
+
+func TestFullNode_ResignLeader_NonLeaderRaftNode(t *testing.T) {
+	// Empty *raftpkg.Node has nil raft field so IsLeader() returns false;
+	// ResignLeader() is a no-op and returns nil.
+	n := &FullNode{raftNode: &raftpkg.Node{}}
+	assert.NoError(t, n.ResignLeader())
+}

pkg/raft/node_test.go

@@ -1,15 +1,81 @@
 package raft
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"testing"
+	"time"
 
 	"github.com/hashicorp/raft"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
+func TestBoltTxClosedFilter_Write(t *testing.T) {
+	specs := map[string]struct {
+		input     string
+		expectFwd bool
+	}{
+		"passes through normal log line": {
+			input:     "some normal log message\n",
+			expectFwd: true,
+		},
+		"drops line containing tx closed": {
+			input:     "Rollback failed: tx closed\n",
+			expectFwd: false,
+		},
+		"drops line with tx closed anywhere": {
+			input:     "error: tx closed due to commit\n",
+			expectFwd: false,
+		},
+	}
+
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			var buf bytes.Buffer
+			f := &boltTxClosedFilter{w: &buf}
+			n, err := f.Write([]byte(spec.input))
+			require.NoError(t, err)
+			assert.Equal(t, len(spec.input), n)
+			if spec.expectFwd {
+				assert.Equal(t, spec.input, buf.String())
+			} else {
+				assert.Empty(t, buf.String())
+			}
+		})
+	}
+}
+
+func TestBuildRaftConfig_ElectionTimeout(t *testing.T) {
+	specs := map[string]struct {
+		cfg                     *Config
+		expectedElectionTimeout time.Duration
+	}{
+		"custom election timeout is applied": {
+			cfg: &Config{
+				NodeID:          "node1",
+				ElectionTimeout: 500 * time.Millisecond,
+			},
+			expectedElectionTimeout: 500 * time.Millisecond,
+		},
+		"zero election timeout uses default": {
+			cfg: &Config{
+				NodeID:          "node1",
+				ElectionTimeout: 0,
+			},
+			expectedElectionTimeout: raft.DefaultConfig().ElectionTimeout,
+		},
+	}
+
+	for name, spec := range specs {
+		t.Run(name, func(t *testing.T) {
+			rc := buildRaftConfig(spec.cfg)
+			assert.Equal(t, spec.expectedElectionTimeout, rc.ElectionTimeout)
+		})
+	}
+}
+
 func TestSplitPeerAddr(t *testing.T) {
 	specs := map[string]struct {
 		in     string