Rewrite tests to use mock instead of directly depending on EtcdServer

Signed-off-by: Marek Siarkowicz <siarkowicz@google.com>

Author: serathius

server/etcdserver/server_test.go

@@ -1578,40 +1578,44 @@ func TestAddFeatureGateMetrics(t *testing.T) {
 }
 
 func TestRequestCurrentIndex_LeaderChangedRace(t *testing.T) {
-	s, _ := setupTestRequestCurrentIndex(t)
+	s, mockRaft := setupTestRequestCurrentIndex(t)
+	r := read.NewRead(s, mockRaft)
 
 	for i := 0; i < 100; i++ {
-		s.r.readStateC <- raft.ReadState{Index: 100}
-		leaderChangedNotifier := s.leaderChanged.Receive()
-		s.leaderChanged.Notify()
+		mockRaft.readStateC <- raft.ReadState{Index: 100}
+		s.leaderChanged <- struct{}{}
 
-		index, err := s.read.RequestCurrentIndex(leaderChangedNotifier)
+		index, err := r.RequestCurrentIndex(s.LeaderChanged())
 		require.ErrorIs(t, err, errors.ErrLeaderChanged)
 		require.Equal(t, uint64(0), index)
 
-		// Clear the readStateC channel for the next iteration,
 		select {
-		case <-s.r.readStateC:
+		case <-mockRaft.readStateC:
+		default:
+		}
+		select {
+		case <-s.leaderChanged:
 		default:
 		}
 	}
 }
 
 func TestRequestCurrentIndex_UniqueRequestID(t *testing.T) {
 	s, mockRaft := setupTestRequestCurrentIndex(t)
+	r := read.NewRead(s, mockRaft)
 
 	wg := sync.WaitGroup{}
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
-		s.read.RequestCurrentIndex(s.leaderChanged.Receive())
+		r.RequestCurrentIndex(s.LeaderChanged())
 	}()
 
 	require.Eventually(t, func() bool {
 		return len(mockRaft.getRequests()) >= 2
 	}, time.Second, 100*time.Millisecond)
 
-	s.leaderChanged.Notify()
+	s.leaderChanged <- struct{}{}
 	wg.Wait()
 
 	seen := make(map[uint64]bool)
@@ -1623,14 +1627,15 @@ func TestRequestCurrentIndex_UniqueRequestID(t *testing.T) {
 
 func TestRequestCurrentIndex_Success(t *testing.T) {
 	s, mockRaft := setupTestRequestCurrentIndex(t)
+	r := read.NewRead(s, mockRaft)
 
 	wg := sync.WaitGroup{}
 	wg.Add(1)
 	var index uint64
 	var err error
 	go func() {
 		defer wg.Done()
-		index, err = s.read.RequestCurrentIndex(s.leaderChanged.Receive())
+		index, err = r.RequestCurrentIndex(s.LeaderChanged())
 	}()
 
 	require.Eventually(t, func() bool {
@@ -1641,7 +1646,7 @@ func TestRequestCurrentIndex_Success(t *testing.T) {
 	reqIDBytes := make([]byte, 8)
 	binary.BigEndian.PutUint64(reqIDBytes, reqID)
 
-	s.r.readStateC <- raft.ReadState{
+	mockRaft.readStateC <- raft.ReadState{
 		Index:      100,
 		RequestCtx: reqIDBytes,
 	}
@@ -1655,14 +1660,15 @@ func TestRequestCurrentIndex_Success(t *testing.T) {
 
 func TestRequestCurrentIndex_WrongRequestID(t *testing.T) {
 	s, mockRaft := setupTestRequestCurrentIndex(t)
+	r := read.NewRead(s, mockRaft)
 
 	wg := sync.WaitGroup{}
 	wg.Add(1)
 	var index uint64
 	var err error
 	go func() {
 		defer wg.Done()
-		index, err = s.read.RequestCurrentIndex(s.leaderChanged.Receive())
+		index, err = r.RequestCurrentIndex(s.LeaderChanged())
 	}()
 
 	require.Eventually(t, func() bool {
@@ -1672,7 +1678,7 @@ func TestRequestCurrentIndex_WrongRequestID(t *testing.T) {
 	wrongReqIDBytes := make([]byte, 8)
 	binary.BigEndian.PutUint64(wrongReqIDBytes, 99999)
 
-	s.r.readStateC <- raft.ReadState{
+	mockRaft.readStateC <- raft.ReadState{
 		Index:      100,
 		RequestCtx: wrongReqIDBytes,
 	}
@@ -1685,7 +1691,7 @@ func TestRequestCurrentIndex_WrongRequestID(t *testing.T) {
 	reqIDBytes := make([]byte, 8)
 	binary.BigEndian.PutUint64(reqIDBytes, reqID)
 
-	s.r.readStateC <- raft.ReadState{
+	mockRaft.readStateC <- raft.ReadState{
 		Index:      99,
 		RequestCtx: reqIDBytes,
 	}
@@ -1698,14 +1704,15 @@ func TestRequestCurrentIndex_WrongRequestID(t *testing.T) {
 
 func TestRequestCurrentIndex_DelayedResponse(t *testing.T) {
 	s, mockRaft := setupTestRequestCurrentIndex(t)
+	r := read.NewRead(s, mockRaft)
 
 	wg := sync.WaitGroup{}
 	wg.Add(1)
 	var index uint64
 	var err error
 	go func() {
 		defer wg.Done()
-		index, err = s.read.RequestCurrentIndex(s.leaderChanged.Receive())
+		index, err = r.RequestCurrentIndex(s.LeaderChanged())
 	}()
 
 	require.Eventually(t, func() bool {
@@ -1718,7 +1725,7 @@ func TestRequestCurrentIndex_DelayedResponse(t *testing.T) {
 	binary.BigEndian.PutUint64(reqIDBytes, reqID)
 
 	select {
-	case s.r.readStateC <- raft.ReadState{
+	case mockRaft.readStateC <- raft.ReadState{
 		Index:      100,
 		RequestCtx: reqIDBytes,
 	}:
@@ -1731,31 +1738,28 @@ func TestRequestCurrentIndex_DelayedResponse(t *testing.T) {
 	require.Equal(t, uint64(100), index)
 }
 
-func setupTestRequestCurrentIndex(t *testing.T) (*EtcdServer, *testRaftNode) {
-	mockRaft := &testRaftNode{}
-	s := &EtcdServer{
-		lgMu:              new(sync.RWMutex),
-		lg:                zaptest.NewLogger(t),
-		reqIDGen:          idutil.NewGenerator(0, time.Time{}),
-		firstCommitInTerm: notify.NewNotifier(),
-		leaderChanged:     notify.NewNotifier(),
-		r: raftNode{
-			raftNodeConfig: raftNodeConfig{
-				Node: mockRaft,
-			},
-			readStateC: make(chan raft.ReadState, 1),
-		},
+func setupTestRequestCurrentIndex(t *testing.T) (*mockServer, *testRaftNode) {
+	s := &mockServer{
+		leaderChanged: make(chan struct{}, 1),
+		stopping:      make(chan struct{}, 1),
+		done:          make(chan struct{}, 1),
+		logger:        zaptest.NewLogger(t),
+		timeout:       5 * time.Second,
+		firstCommit:   make(chan struct{}, 1),
+	}
+	mockRaft := &testRaftNode{
+		readStateC: make(chan raft.ReadState, 1),
 	}
-	s.read = read.NewRead(s, &s.r)
 	return s, mockRaft
 }
 
 type testRaftNode struct {
-	raft.Node
+	readStateC        chan raft.ReadState
 	mu                sync.Mutex
 	readIndexRequests []uint64
 }
 
+func (m *testRaftNode) ReadState() <-chan raft.ReadState { return m.readStateC }
 func (m *testRaftNode) ReadIndex(ctx context.Context, rctx []byte) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -1772,3 +1776,24 @@ func (m *testRaftNode) getRequests() []uint64 {
 	copy(res, m.readIndexRequests)
 	return res
 }
+
+type mockServer struct {
+	leaderChanged chan struct{}
+	stopping      chan struct{}
+	done          chan struct{}
+	logger        *zap.Logger
+	appliedIndex  uint64
+	nextRequestID uint64
+	timeout       time.Duration
+	firstCommit   chan struct{}
+}
+
+func (s *mockServer) LeaderChanged() <-chan struct{}            { return s.leaderChanged }
+func (s *mockServer) Stopping() <-chan struct{}                 { return s.stopping }
+func (s *mockServer) Logger() *zap.Logger                       { return s.logger }
+func (s *mockServer) AppliedIndex() uint64                      { return s.appliedIndex }
+func (s *mockServer) ApplyWait(deadline uint64) <-chan struct{} { return nil }
+func (s *mockServer) NextRequestID() uint64                     { s.nextRequestID++; return s.nextRequestID }
+func (s *mockServer) RequestTimeout() time.Duration             { return s.timeout }
+func (s *mockServer) FirstCommitInTermNotify() <-chan struct{}  { return s.firstCommit }
+func (s *mockServer) Done() <-chan struct{}                     { return s.done }