Skip to content

Commit 93ba0a1

Browse files
317787106317787106
committed
test(net): add MessageHandlerTest
1 parent 382a405 commit 93ba0a1

2 files changed

Lines changed: 154 additions & 0 deletions

File tree

‎framework/src/main/java/org/tron/core/net/service/handshake/HandshakeService.java‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -35,19 +35,22 @@ public void startHandshake(PeerConnection peer) {
3535

3636
public void processHelloMessage(PeerConnection peer, HelloMessage msg) {
3737
if (peer.getHelloMessageReceive() != null) {
38+
System.out.println("11111111111");
3839
logger.warn("Peer {} receive dup hello message", peer.getInetSocketAddress());
3940
peer.disconnect(ReasonCode.BAD_PROTOCOL);
4041
return;
4142
}
4243

4344
TronNetService.getP2pService().updateNodeId(peer.getChannel(), msg.getFrom().getHexId());
4445
if (peer.isDisconnect()) {
46+
System.out.println("222222222");
4547
logger.info("Duplicate Peer {}", peer.getInetSocketAddress());
4648
peer.disconnect(ReasonCode.DUPLICATE_PEER);
4749
return;
4850
}
4951

5052
if (!msg.valid()) {
53+
System.out.println("333333333");
5154
logger.warn("Peer {} invalid hello message parameters, "
5255
+ "GenesisBlockId: {}, SolidBlockId: {}, HeadBlockId: {}",
5356
peer.getInetSocketAddress(),
@@ -61,20 +64,23 @@ public void processHelloMessage(PeerConnection peer, HelloMessage msg) {
6164
peer.setAddress(msg.getHelloMessage().getAddress());
6265

6366
if (!relayService.checkHelloMessage(msg, peer.getChannel())) {
67+
System.out.println("44444444444");
6468
peer.disconnect(ReasonCode.UNEXPECTED_IDENTITY);
6569
return;
6670
}
6771

6872
long headBlockNum = chainBaseManager.getHeadBlockNum();
6973
long lowestBlockNum = msg.getLowestBlockNum();
7074
if (lowestBlockNum > headBlockNum) {
75+
System.out.println("55555555555");
7176
logger.info("Peer {} miss block, lowestBlockNum:{}, headBlockNum:{}",
7277
peer.getInetSocketAddress(), lowestBlockNum, headBlockNum);
7378
peer.disconnect(ReasonCode.LIGHT_NODE_SYNC_FAIL);
7479
return;
7580
}
7681

7782
if (msg.getVersion() != Args.getInstance().getNodeP2pVersion()) {
83+
System.out.println("6666666666");
7884
logger.info("Peer {} different p2p version, peer->{}, me->{}",
7985
peer.getInetSocketAddress(), msg.getVersion(),
8086
Args.getInstance().getNodeP2pVersion());
@@ -84,6 +90,7 @@ public void processHelloMessage(PeerConnection peer, HelloMessage msg) {
8490

8591
if (!Arrays.equals(chainBaseManager.getGenesisBlockId().getBytes(),
8692
msg.getGenesisBlockId().getBytes())) {
93+
System.out.println("7777777777");
8794
logger.info("Peer {} different genesis block, peer->{}, me->{}",
8895
peer.getInetSocketAddress(),
8996
msg.getGenesisBlockId().getString(),
@@ -94,6 +101,7 @@ public void processHelloMessage(PeerConnection peer, HelloMessage msg) {
94101

95102
if (chainBaseManager.getSolidBlockId().getNum() >= msg.getSolidBlockId().getNum()
96103
&& !chainBaseManager.containBlockInMainChain(msg.getSolidBlockId())) {
104+
System.out.println("88888888888");
97105
logger.info("Peer {} different solid block, peer->{}, me->{}",
98106
peer.getInetSocketAddress(),
99107
msg.getSolidBlockId().getString(),
@@ -104,13 +112,15 @@ public void processHelloMessage(PeerConnection peer, HelloMessage msg) {
104112

105113
if (msg.getHeadBlockId().getNum() < chainBaseManager.getHeadBlockId().getNum()
106114
&& peer.getInetSocketAddress().equals(effectiveCheckService.getCur())) {
115+
System.out.println("99999999999");
107116
logger.info("Peer's head block {} is below than we, peer->{}, me->{}",
108117
peer.getInetSocketAddress(), msg.getHeadBlockId().getNum(),
109118
chainBaseManager.getHeadBlockId().getNum());
110119
peer.disconnect(ReasonCode.BELOW_THAN_ME);
111120
return;
112121
}
113122

123+
System.out.println("000000000");
114124
peer.setHelloMessageReceive(msg);
115125

116126
peer.getChannel().updateAvgLatency(

‎framework/src/test/java/org/tron/core/net/messagehandler/MessageHandlerTest.java‎

Lines changed: 144 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,144 @@
1+
package org.tron.core.net.messagehandler;
2+
3+
4+
import static org.mockito.Mockito.mock;
5+
6+
import com.google.protobuf.ByteString;
7+
import java.lang.reflect.Field;
8+
import java.lang.reflect.InvocationTargetException;
9+
import java.lang.reflect.Method;
10+
import java.net.InetSocketAddress;
11+
import java.util.ArrayList;
12+
import java.util.Collections;
13+
import org.junit.Assert;
14+
import org.junit.Before;
15+
import org.junit.BeforeClass;
16+
import org.junit.Test;
17+
import org.mockito.Mockito;
18+
import org.springframework.context.ApplicationContext;
19+
import org.tron.common.application.TronApplicationContext;
20+
import org.tron.common.utils.ReflectUtils;
21+
import org.tron.common.utils.Sha256Hash;
22+
import org.tron.consensus.pbft.message.PbftMessage;
23+
import org.tron.core.ChainBaseManager;
24+
import org.tron.core.Constant;
25+
import org.tron.core.capsule.BlockCapsule;
26+
import org.tron.core.config.DefaultConfig;
27+
import org.tron.core.config.args.Args;
28+
import org.tron.core.net.P2pEventHandlerImpl;
29+
import org.tron.core.net.TronNetService;
30+
import org.tron.core.net.message.handshake.HelloMessage;
31+
import org.tron.core.net.message.keepalive.PingMessage;
32+
import org.tron.core.net.peer.PeerConnection;
33+
import org.tron.core.net.peer.PeerManager;
34+
import org.tron.p2p.P2pConfig;
35+
import org.tron.p2p.base.Parameter;
36+
import org.tron.p2p.connection.Channel;
37+
import org.tron.p2p.discover.Node;
38+
import org.tron.p2p.utils.NetUtil;
39+
import org.tron.protos.Protocol;
40+
import org.tron.protos.Protocol.ReasonCode;
41+
42+
public class MessageHandlerTest {
43+
44+
private static TronApplicationContext context;
45+
private PeerConnection peer;
46+
private static P2pEventHandlerImpl p2pEventHandler;
47+
private static ApplicationContext ctx;
48+
private static String dbPath = "output-message-handler-test";
49+
50+
51+
@BeforeClass
52+
public static void init() throws Exception {
53+
Args.setParam(new String[] {"--output-directory", dbPath, "--debug"},
54+
Constant.TEST_CONF);
55+
context = new TronApplicationContext(DefaultConfig.class);
56+
p2pEventHandler = context.getBean(P2pEventHandlerImpl.class);
57+
ctx = (ApplicationContext) ReflectUtils.getFieldObject(p2pEventHandler, "ctx");
58+
59+
TronNetService tronNetService = context.getBean(TronNetService.class);
60+
Parameter.p2pConfig = new P2pConfig();
61+
ReflectUtils.setFieldValue(tronNetService, "p2pConfig", Parameter.p2pConfig);
62+
}
63+
64+
65+
@Before
66+
public void clearPeers() throws NoSuchFieldException, IllegalAccessException {
67+
Field field = PeerManager.class.getDeclaredField("peers");
68+
field.setAccessible(true);
69+
field.set(PeerManager.class, Collections.synchronizedList(new ArrayList<>()));
70+
}
71+
72+
@Test
73+
public void testPbft() {
74+
InetSocketAddress a1 = new InetSocketAddress("127.0.0.1", 10001);
75+
Channel c1 = mock(Channel.class);
76+
Mockito.when(c1.getInetSocketAddress()).thenReturn(a1);
77+
Mockito.when(c1.getInetAddress()).thenReturn(a1.getAddress());
78+
p2pEventHandler.onConnect(c1);
79+
Assert.assertEquals(1, PeerManager.getPeers().size());
80+
Assert.assertFalse(c1.isDisconnect());
81+
82+
peer = PeerManager.getPeers().get(0);
83+
BlockCapsule blockCapsule = new BlockCapsule(1, Sha256Hash.ZERO_HASH,
84+
System.currentTimeMillis(), ByteString.EMPTY);
85+
PbftMessage pbftMessage = PbftMessage.fullNodePrePrepareBlockMsg(blockCapsule, 0L);
86+
p2pEventHandler.onMessage(peer.getChannel(), pbftMessage.getSendBytes());
87+
88+
InetSocketAddress a2 = new InetSocketAddress("127.0.0.1", 10002);
89+
Channel c2 = mock(Channel.class);
90+
Mockito.when(c2.getInetSocketAddress()).thenReturn(a2);
91+
Mockito.when(c2.getInetAddress()).thenReturn(a2.getAddress());
92+
p2pEventHandler.onMessage(c2, pbftMessage.getSendBytes());
93+
94+
Assert.assertEquals(1, PeerManager.getPeers().size());
95+
}
96+
97+
@Test
98+
public void testPing() {
99+
InetSocketAddress a1 = new InetSocketAddress("127.0.0.1", 10001);
100+
Channel c1 = mock(Channel.class);
101+
Mockito.when(c1.getInetSocketAddress()).thenReturn(a1);
102+
Mockito.when(c1.getInetAddress()).thenReturn(a1.getAddress());
103+
PeerManager.add(ctx, c1);
104+
105+
PingMessage pingMessage = new PingMessage();
106+
p2pEventHandler.onMessage(c1, pingMessage.getSendBytes());
107+
Assert.assertEquals(1, PeerManager.getPeers().size());
108+
}
109+
110+
@Test
111+
public void testHelloMessage()
112+
throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
113+
InetSocketAddress a1 = new InetSocketAddress("127.0.0.1", 10001);
114+
Channel c1 = mock(Channel.class);
115+
Mockito.when(c1.getInetSocketAddress()).thenReturn(a1);
116+
Mockito.when(c1.getInetAddress()).thenReturn(a1.getAddress());
117+
PeerManager.add(ctx, c1);
118+
119+
Method method = p2pEventHandler.getClass()
120+
.getDeclaredMethod("onMessage", Channel.class, byte[].class);
121+
method.setAccessible(true);
122+
123+
//ok
124+
peer = PeerManager.getPeers().get(0);
125+
Node node = new Node(NetUtil.getNodeId(),
126+
a1.getAddress().getHostAddress(),
127+
null,
128+
a1.getPort());
129+
HelloMessage helloMessage = new HelloMessage(node, System.currentTimeMillis(),
130+
ChainBaseManager.getChainBaseManager());
131+
method.invoke(p2pEventHandler, c1, helloMessage.getSendBytes());
132+
133+
//dup hello message
134+
peer.setHelloMessageReceive(helloMessage);
135+
method.invoke(p2pEventHandler, c1, helloMessage.getSendBytes());
136+
137+
//dup peer
138+
peer.setHelloMessageReceive(null);
139+
Mockito.when(c1.isDisconnect()).thenReturn(true);
140+
method.invoke(p2pEventHandler, c1, helloMessage.getSendBytes());
141+
142+
// Assert.assertEquals(1, PeerManager.getPeers().size());
143+
}
144+
}

0 commit comments

Comments
 (0)