1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
package protocols.implementations;
import core.VSInternalProcess;
import core.VSMessage;
import core.VSTask;
import core.VSTaskManager;
import core.time.VSVectorTime;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import prefs.VSPrefs;
import simulator.VSSimulatorVisualization;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Unit tests for VSRaftProtocol heartbeat behavior.
*/
class VSRaftProtocolTest {
@Mock
private VSInternalProcess mockProcess;
@Mock
private VSSimulatorVisualization mockCanvas;
@Mock
private VSTaskManager mockTaskManager;
@Mock
private VSPrefs mockPrefs;
@Mock
private VSVectorTime mockVectorTime;
private VSRaftProtocol protocol;
@BeforeEach
void setUp() {
MockitoAnnotations.openMocks(this);
protocol = new VSRaftProtocol();
protocol.process = mockProcess;
protocol.prefs = mockPrefs;
protocol.isServer(true);
when(mockProcess.getSimulatorCanvas()).thenReturn(mockCanvas);
when(mockCanvas.getTaskManager()).thenReturn(mockTaskManager);
when(mockProcess.getPrefs()).thenReturn(mockPrefs);
when(mockProcess.getVectorTime()).thenReturn(mockVectorTime);
when(mockVectorTime.getCopy()).thenReturn(mockVectorTime);
when(mockPrefs.getString(anyString())).thenReturn("TestString");
when(mockProcess.getTime()).thenReturn(100L);
when(mockProcess.getProcessID()).thenReturn(7);
}
@Test
void testOnStartBecomesLeaderAndSendsHeartbeat() {
ArgumentCaptor<VSMessage> messageCaptor =
ArgumentCaptor.forClass(VSMessage.class);
ArgumentCaptor<VSTask> taskCaptor = ArgumentCaptor.forClass(VSTask.class);
protocol.onStart();
verify(mockProcess).sendMessage(messageCaptor.capture());
verify(mockTaskManager).addTask(taskCaptor.capture());
VSMessage heartbeat = messageCaptor.getValue();
assertEquals("heartbeat", heartbeat.getString("type"));
assertEquals(0, heartbeat.getInteger("term"));
assertEquals(7, heartbeat.getInteger("leaderId"));
assertEquals(1600L, taskCaptor.getValue().getTaskTime());
}
@Test
void testServerScheduleSendsHeartbeatWhenLeader() {
ArgumentCaptor<VSMessage> messageCaptor =
ArgumentCaptor.forClass(VSMessage.class);
ArgumentCaptor<VSTask> taskCaptor = ArgumentCaptor.forClass(VSTask.class);
protocol.onStart();
protocol.onServerScheduleStart();
verify(mockProcess, times(2)).sendMessage(messageCaptor.capture());
verify(mockTaskManager, times(2)).addTask(taskCaptor.capture());
assertEquals(2, messageCaptor.getAllValues().size());
assertEquals(2, taskCaptor.getAllValues().size());
VSMessage scheduledHeartbeat = messageCaptor.getAllValues().get(1);
assertEquals("heartbeat", scheduledHeartbeat.getString("type"));
assertEquals(0, scheduledHeartbeat.getInteger("term"));
assertEquals(7, scheduledHeartbeat.getInteger("leaderId"));
assertEquals(1600L, taskCaptor.getAllValues().get(1).getTaskTime());
}
@Test
void testServerScheduleDoesNothingWhenNotLeader() {
protocol.currentContextIsServer(true);
protocol.onServerSchedule();
verify(mockProcess, never()).sendMessage(org.mockito.ArgumentMatchers.any());
verify(mockTaskManager, never()).addTask(org.mockito.ArgumentMatchers.any());
}
}
|
