Skip to content

Commit ba20e25

Browse files
xxo1shinexxo1shine
authored
Merge pull request #5494 from ss3344520/unit-test
test(net): add unit test for peer connection
2 parents de23b55 + 47099a2 commit ba20e25

File tree

4 files changed

+425
-1
lines changed

4 files changed

+425
-1
lines changed

‎framework/src/main/java/org/tron/core/net/peer/PeerConnection.java‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -204,7 +204,6 @@ public void onDisconnect() {
204204
syncBlockToFetch.clear();
205205
syncBlockRequested.clear();
206206
syncBlockInProcess.clear();
207-
syncBlockInProcess.clear();
208207
}
209208

210209
public String log() {

‎framework/src/test/java/org/tron/core/net/peer/PeerConnectionTest.java‎

Lines changed: 260 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,28 @@
11
package org.tron.core.net.peer;
22

3+
import static org.mockito.Mockito.mock;
4+
5+
import java.net.InetSocketAddress;
6+
import java.util.ArrayList;
7+
import java.util.LinkedList;
8+
import java.util.List;
9+
310
import org.junit.Assert;
411
import org.junit.Test;
12+
import org.mockito.Mockito;
13+
import org.tron.common.overlay.message.Message;
14+
import org.tron.common.utils.Pair;
15+
import org.tron.common.utils.ReflectUtils;
16+
import org.tron.common.utils.Sha256Hash;
17+
import org.tron.core.capsule.BlockCapsule;
18+
import org.tron.core.net.message.adv.InventoryMessage;
19+
import org.tron.core.net.message.handshake.HelloMessage;
20+
import org.tron.core.net.message.keepalive.PingMessage;
21+
import org.tron.core.net.message.keepalive.PongMessage;
22+
import org.tron.core.net.service.adv.AdvService;
23+
import org.tron.core.net.service.sync.SyncService;
24+
import org.tron.p2p.connection.Channel;
25+
import org.tron.protos.Protocol;
526

627
public class PeerConnectionTest {
728

@@ -16,4 +37,243 @@ public void testVariableDefaultValue() {
1637
Assert.assertTrue(peerConnection.isNeedSyncFromUs());
1738
Assert.assertTrue(!peerConnection.isSyncFinish());
1839
}
40+
41+
@Test
42+
public void testOnDisconnect() {
43+
PeerConnection peerConnection = new PeerConnection();
44+
45+
SyncService syncService = mock(SyncService.class);
46+
ReflectUtils.setFieldValue(peerConnection, "syncService", syncService);
47+
48+
AdvService advService = mock(AdvService.class);
49+
ReflectUtils.setFieldValue(peerConnection, "advService", advService);
50+
51+
Item item = new Item(Sha256Hash.ZERO_HASH, Protocol.Inventory.InventoryType.TRX);
52+
Long time = System.currentTimeMillis();
53+
BlockCapsule.BlockId blockId = new BlockCapsule.BlockId();
54+
peerConnection.getAdvInvReceive().put(item, time);
55+
peerConnection.getAdvInvSpread().put(item, time);
56+
peerConnection.getSyncBlockIdCache().put(item.getHash(), time);
57+
peerConnection.getSyncBlockToFetch().add(blockId);
58+
peerConnection.getSyncBlockRequested().put(blockId, time);
59+
peerConnection.getSyncBlockInProcess().add(blockId);
60+
61+
peerConnection.onDisconnect();
62+
63+
//Assert.assertEquals(0, peerConnection.getAdvInvReceive().size());
64+
//Assert.assertEquals(0, peerConnection.getAdvInvSpread().size());
65+
//Assert.assertEquals(0, peerConnection.getSyncBlockIdCache().size());
66+
Assert.assertEquals(0, peerConnection.getSyncBlockToFetch().size());
67+
Assert.assertEquals(0, peerConnection.getSyncBlockRequested().size());
68+
Assert.assertEquals(0, peerConnection.getSyncBlockInProcess().size());
69+
}
70+
71+
@Test
72+
public void testIsIdle() {
73+
PeerConnection peerConnection = new PeerConnection();
74+
boolean f = peerConnection.isIdle();
75+
Assert.assertTrue(f);
76+
77+
Item item = new Item(Sha256Hash.ZERO_HASH, Protocol.Inventory.InventoryType.TRX);
78+
Long time = System.currentTimeMillis();
79+
peerConnection.getAdvInvRequest().put(item, time);
80+
f = peerConnection.isIdle();
81+
Assert.assertTrue(!f);
82+
83+
peerConnection.getAdvInvRequest().clear();
84+
f = peerConnection.isIdle();
85+
Assert.assertTrue(f);
86+
87+
BlockCapsule.BlockId blockId = new BlockCapsule.BlockId();
88+
peerConnection.getSyncBlockRequested().put(blockId, time);
89+
f = peerConnection.isIdle();
90+
Assert.assertTrue(!f);
91+
92+
peerConnection.getSyncBlockRequested().clear();
93+
f = peerConnection.isIdle();
94+
Assert.assertTrue(f);
95+
96+
peerConnection.setSyncChainRequested(new Pair<>(new LinkedList<>(), time));
97+
f = peerConnection.isIdle();
98+
Assert.assertTrue(!f);
99+
}
100+
101+
@Test
102+
public void testOnConnect() {
103+
PeerConnection peerConnection = new PeerConnection();
104+
SyncService syncService = mock(SyncService.class);
105+
ReflectUtils.setFieldValue(peerConnection, "syncService", syncService);
106+
107+
HelloMessage m1 = mock(HelloMessage.class);
108+
BlockCapsule.BlockId b1 = new BlockCapsule.BlockId(Sha256Hash.ZERO_HASH, 1);
109+
Mockito.when(m1.getHeadBlockId()).thenReturn(b1);
110+
111+
HelloMessage m2 = mock(HelloMessage.class);
112+
BlockCapsule.BlockId b2 = new BlockCapsule.BlockId(Sha256Hash.ZERO_HASH, 2);
113+
Mockito.when(m2.getHeadBlockId()).thenReturn(b2);
114+
115+
Assert.assertTrue(peerConnection.isNeedSyncFromUs());
116+
Assert.assertTrue(peerConnection.isNeedSyncFromPeer());
117+
118+
ReflectUtils.setFieldValue(peerConnection, "helloMessageReceive", m1);
119+
ReflectUtils.setFieldValue(peerConnection, "helloMessageSend", m2);
120+
peerConnection.onConnect();
121+
Assert.assertTrue(peerConnection.isNeedSyncFromUs());
122+
Assert.assertTrue(!peerConnection.isNeedSyncFromPeer());
123+
124+
peerConnection.setNeedSyncFromPeer(true);
125+
peerConnection.setNeedSyncFromUs(true);
126+
ReflectUtils.setFieldValue(peerConnection, "helloMessageReceive", m2);
127+
ReflectUtils.setFieldValue(peerConnection, "helloMessageSend", m1);
128+
peerConnection.onConnect();
129+
Assert.assertTrue(!peerConnection.isNeedSyncFromUs());
130+
Assert.assertTrue(peerConnection.isNeedSyncFromPeer());
131+
132+
peerConnection.setNeedSyncFromPeer(true);
133+
peerConnection.setNeedSyncFromUs(true);
134+
ReflectUtils.setFieldValue(peerConnection, "helloMessageReceive", m1);
135+
ReflectUtils.setFieldValue(peerConnection, "helloMessageSend", m1);
136+
peerConnection.onConnect();
137+
Assert.assertTrue(!peerConnection.isNeedSyncFromUs());
138+
Assert.assertTrue(!peerConnection.isNeedSyncFromPeer());
139+
}
140+
141+
@Test
142+
public void testSetChannel() {
143+
PeerConnection peerConnection = new PeerConnection();
144+
145+
InetSocketAddress inetSocketAddress =
146+
new InetSocketAddress("127.0.0.2", 10001);
147+
Channel c1 = new Channel();
148+
ReflectUtils.setFieldValue(c1, "inetSocketAddress", inetSocketAddress);
149+
ReflectUtils.setFieldValue(c1, "inetAddress", inetSocketAddress.getAddress());
150+
151+
List<InetSocketAddress> relayNodes = new ArrayList<>();
152+
ReflectUtils.setFieldValue(peerConnection, "relayNodes", relayNodes);
153+
154+
peerConnection.setChannel(c1);
155+
Assert.assertTrue(!peerConnection.isRelayPeer());
156+
157+
relayNodes.add(inetSocketAddress);
158+
peerConnection.setChannel(c1);
159+
Assert.assertTrue(peerConnection.isRelayPeer());
160+
}
161+
162+
@Test
163+
public void testIsSyncFinish() {
164+
PeerConnection peerConnection = new PeerConnection();
165+
boolean f = peerConnection.isSyncFinish();
166+
Assert.assertTrue(!f);
167+
168+
peerConnection.setNeedSyncFromUs(false);
169+
f = peerConnection.isSyncFinish();
170+
Assert.assertTrue(!f);
171+
172+
peerConnection.setNeedSyncFromPeer(false);
173+
f = peerConnection.isSyncFinish();
174+
Assert.assertTrue(f);
175+
}
176+
177+
@Test
178+
public void testCheckAndPutAdvInvRequest() {
179+
PeerConnection peerConnection = new PeerConnection();
180+
Item item = new Item(Sha256Hash.ZERO_HASH, Protocol.Inventory.InventoryType.TRX);
181+
Long time = System.currentTimeMillis();
182+
boolean f = peerConnection.checkAndPutAdvInvRequest(item, time);
183+
Assert.assertTrue(f);
184+
185+
f = peerConnection.checkAndPutAdvInvRequest(item, time);
186+
Assert.assertTrue(!f);
187+
}
188+
189+
@Test
190+
public void testEquals() {
191+
List<InetSocketAddress> relayNodes = new ArrayList<>();
192+
193+
PeerConnection p1 = new PeerConnection();
194+
InetSocketAddress inetSocketAddress1 =
195+
new InetSocketAddress("127.0.0.2", 10001);
196+
Channel c1 = new Channel();
197+
ReflectUtils.setFieldValue(c1, "inetSocketAddress", inetSocketAddress1);
198+
ReflectUtils.setFieldValue(c1, "inetAddress", inetSocketAddress1.getAddress());
199+
ReflectUtils.setFieldValue(p1, "relayNodes", relayNodes);
200+
p1.setChannel(c1);
201+
202+
PeerConnection p2 = new PeerConnection();
203+
InetSocketAddress inetSocketAddress2 =
204+
new InetSocketAddress("127.0.0.2", 10002);
205+
Channel c2 = new Channel();
206+
ReflectUtils.setFieldValue(c2, "inetSocketAddress", inetSocketAddress2);
207+
ReflectUtils.setFieldValue(c2, "inetAddress", inetSocketAddress2.getAddress());
208+
ReflectUtils.setFieldValue(p2, "relayNodes", relayNodes);
209+
p2.setChannel(c2);
210+
211+
PeerConnection p3 = new PeerConnection();
212+
InetSocketAddress inetSocketAddress3 =
213+
new InetSocketAddress("127.0.0.2", 10002);
214+
Channel c3 = new Channel();
215+
ReflectUtils.setFieldValue(c3, "inetSocketAddress", inetSocketAddress3);
216+
ReflectUtils.setFieldValue(c3, "inetAddress", inetSocketAddress3.getAddress());
217+
ReflectUtils.setFieldValue(p3, "relayNodes", relayNodes);
218+
p3.setChannel(c3);
219+
220+
Assert.assertTrue(p1.equals(p1));
221+
Assert.assertTrue(!p1.equals(p2));
222+
Assert.assertTrue(p2.equals(p3));
223+
}
224+
225+
@Test
226+
public void testHashCode() {
227+
List<InetSocketAddress> relayNodes = new ArrayList<>();
228+
229+
PeerConnection p1 = new PeerConnection();
230+
InetSocketAddress inetSocketAddress1 =
231+
new InetSocketAddress("127.0.0.2", 10001);
232+
Channel c1 = new Channel();
233+
ReflectUtils.setFieldValue(c1, "inetSocketAddress", inetSocketAddress1);
234+
ReflectUtils.setFieldValue(c1, "inetAddress", inetSocketAddress1.getAddress());
235+
ReflectUtils.setFieldValue(p1, "relayNodes", relayNodes);
236+
p1.setChannel(c1);
237+
238+
PeerConnection p2 = new PeerConnection();
239+
InetSocketAddress inetSocketAddress2 =
240+
new InetSocketAddress("127.0.0.2", 10002);
241+
Channel c2 = new Channel();
242+
ReflectUtils.setFieldValue(c2, "inetSocketAddress", inetSocketAddress2);
243+
ReflectUtils.setFieldValue(c2, "inetAddress", inetSocketAddress2.getAddress());
244+
ReflectUtils.setFieldValue(p2, "relayNodes", relayNodes);
245+
p2.setChannel(c2);
246+
247+
PeerConnection p3 = new PeerConnection();
248+
InetSocketAddress inetSocketAddress3 =
249+
new InetSocketAddress("127.0.0.2", 10002);
250+
Channel c3 = new Channel();
251+
ReflectUtils.setFieldValue(c3, "inetSocketAddress", inetSocketAddress3);
252+
ReflectUtils.setFieldValue(c3, "inetAddress", inetSocketAddress3.getAddress());
253+
ReflectUtils.setFieldValue(p3, "relayNodes", relayNodes);
254+
p3.setChannel(c3);
255+
256+
Assert.assertTrue(p1.hashCode() != p2.hashCode());
257+
Assert.assertTrue(p2.hashCode() == p3.hashCode());
258+
}
259+
260+
@Test
261+
public void testNeedToLog() throws Exception {
262+
Message msg = new PingMessage();
263+
boolean f = PeerConnection.needToLog(msg);
264+
Assert.assertTrue(!f);
265+
266+
msg = new PongMessage();
267+
f = PeerConnection.needToLog(msg);
268+
Assert.assertTrue(!f);
269+
270+
msg = new InventoryMessage(new ArrayList<>(), Protocol.Inventory.InventoryType.TRX);
271+
f = PeerConnection.needToLog(msg);
272+
Assert.assertTrue(!f);
273+
274+
msg = new InventoryMessage(new ArrayList<>(), Protocol.Inventory.InventoryType.BLOCK);
275+
f = PeerConnection.needToLog(msg);
276+
Assert.assertTrue(f);
277+
}
278+
19279
}

0 commit comments

Comments
 (0)