Skip to content

Commit 419570c

Browse files
jwrctjwrct
authored
Merge pull request #5459 from jwrct/add_test
test(net): add message handler test cases
2 parents 94e1a84 + 9d089e7 commit 419570c

File tree

4 files changed

+322
-0
lines changed

4 files changed

+322
-0
lines changed

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

Lines changed: 60 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,65 @@
11
package org.tron.core.net.messagehandler;
22

3+
import com.google.common.cache.Cache;
4+
import com.google.common.cache.CacheBuilder;
5+
import java.lang.reflect.Field;
6+
import java.util.LinkedList;
7+
import java.util.List;
8+
import java.util.concurrent.TimeUnit;
9+
import org.junit.Assert;
10+
import org.junit.Test;
11+
import org.mockito.Mockito;
12+
import org.tron.common.utils.ReflectUtils;
13+
import org.tron.common.utils.Sha256Hash;
14+
import org.tron.core.capsule.BlockCapsule;
15+
import org.tron.core.config.Parameter;
16+
import org.tron.core.net.TronNetDelegate;
17+
import org.tron.core.net.message.adv.BlockMessage;
18+
import org.tron.core.net.message.adv.FetchInvDataMessage;
19+
import org.tron.core.net.peer.Item;
20+
import org.tron.core.net.peer.PeerConnection;
21+
import org.tron.core.net.service.adv.AdvService;
22+
import org.tron.protos.Protocol;
23+
24+
25+
326
public class FetchInvDataMsgHandlerTest {
427

28+
@Test
29+
public void testProcessMessage() throws Exception {
30+
FetchInvDataMsgHandler fetchInvDataMsgHandler = new FetchInvDataMsgHandler();
31+
PeerConnection peer = Mockito.mock(PeerConnection.class);
32+
TronNetDelegate tronNetDelegate = Mockito.mock(TronNetDelegate.class);
33+
AdvService advService = Mockito.mock(AdvService.class);
34+
35+
Field field = FetchInvDataMsgHandler.class.getDeclaredField("tronNetDelegate");
36+
field.setAccessible(true);
37+
field.set(fetchInvDataMsgHandler, tronNetDelegate);
38+
39+
Mockito.when(tronNetDelegate.allowPBFT()).thenReturn(false);
40+
41+
BlockCapsule.BlockId blockId = new BlockCapsule.BlockId();
42+
List<Sha256Hash> blockIds = new LinkedList<>();
43+
blockIds.add(blockId);
44+
45+
Cache<Item, Long> advInvSpread = CacheBuilder.newBuilder().maximumSize(20000)
46+
.expireAfterWrite(1, TimeUnit.HOURS).recordStats().build();
47+
Mockito.when(peer.getAdvInvSpread()).thenReturn(advInvSpread);
48+
Mockito.when(peer.isNeedSyncFromUs()).thenReturn(true);
49+
Mockito.when(peer.isSyncFinish()).thenReturn(false);
50+
Mockito.when(peer.getBlockBothHave()).thenReturn(blockId);
51+
Cache<Sha256Hash, Long> syncBlockIdCache = CacheBuilder.newBuilder()
52+
.maximumSize(2 * Parameter.NetConstants.SYNC_FETCH_BATCH_NUM).recordStats().build();
53+
Mockito.when(peer.getSyncBlockIdCache()).thenReturn(syncBlockIdCache);
54+
Mockito.when(peer.getLastSyncBlockId()).thenReturn(blockId);
55+
BlockCapsule blockCapsule = new BlockCapsule(1, Sha256Hash.ZERO_HASH,
56+
System.currentTimeMillis(), Sha256Hash.ZERO_HASH.getByteString());
57+
Mockito.when(advService.getMessage(new Item(blockId, Protocol.Inventory.InventoryType.BLOCK)))
58+
.thenReturn(new BlockMessage(blockCapsule));
59+
ReflectUtils.setFieldValue(fetchInvDataMsgHandler, "advService", advService);
60+
61+
fetchInvDataMsgHandler.processMessage(peer,
62+
new FetchInvDataMessage(blockIds, Protocol.Inventory.InventoryType.BLOCK));
63+
Assert.assertNotNull(syncBlockIdCache.getIfPresent(blockId));
64+
}
565
}

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

Lines changed: 57 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,57 @@
1+
package org.tron.core.net.messagehandler;
2+
3+
import com.alibaba.fastjson.JSON;
4+
import com.google.protobuf.ByteString;
5+
import java.lang.reflect.Field;
6+
import java.util.ArrayList;
7+
import java.util.Map;
8+
import org.junit.Assert;
9+
import org.junit.Test;
10+
import org.mockito.Mockito;
11+
import org.tron.common.utils.Sha256Hash;
12+
import org.tron.core.ChainBaseManager;
13+
import org.tron.core.capsule.BlockCapsule;
14+
import org.tron.core.capsule.PbftSignCapsule;
15+
import org.tron.core.db.PbftSignDataStore;
16+
import org.tron.core.net.message.pbft.PbftCommitMessage;
17+
import org.tron.core.store.DynamicPropertiesStore;
18+
import org.tron.protos.Protocol;
19+
20+
public class PbftDataSyncHandlerTest {
21+
@Test
22+
public void testProcessMessage() throws Exception {
23+
PbftDataSyncHandler pbftDataSyncHandler = new PbftDataSyncHandler();
24+
BlockCapsule blockCapsule = new BlockCapsule(1, Sha256Hash.ZERO_HASH,
25+
System.currentTimeMillis(), ByteString.EMPTY);
26+
Protocol.PBFTMessage.Raw.Builder rawBuilder = Protocol.PBFTMessage.Raw.newBuilder();
27+
rawBuilder.setViewN(blockCapsule.getNum())
28+
.setEpoch(0)
29+
.setDataType(Protocol.PBFTMessage.DataType.BLOCK)
30+
.setMsgType(Protocol.PBFTMessage.MsgType.PREPREPARE)
31+
.setData(blockCapsule.getBlockId().getByteString());
32+
Protocol.PBFTMessage.Raw raw = rawBuilder.build();
33+
PbftSignCapsule pbftSignCapsule = new PbftSignCapsule(raw.toByteString(), new ArrayList<>());
34+
PbftCommitMessage pbftCommitMessage = new PbftCommitMessage(pbftSignCapsule);
35+
pbftDataSyncHandler.processMessage(null, pbftCommitMessage);
36+
Assert.assertEquals(Protocol.PBFTMessage.Raw.parseFrom(
37+
pbftCommitMessage.getPBFTCommitResult().getData()).getViewN(), 1);
38+
39+
DynamicPropertiesStore dynamicPropertiesStore = Mockito.mock(DynamicPropertiesStore.class);
40+
PbftSignDataStore pbftSignDataStore = Mockito.mock(PbftSignDataStore.class);
41+
ChainBaseManager chainBaseManager = Mockito.mock(ChainBaseManager.class);
42+
Mockito.when(chainBaseManager.getDynamicPropertiesStore()).thenReturn(dynamicPropertiesStore);
43+
Mockito.when(dynamicPropertiesStore.allowPBFT()).thenReturn(true);
44+
Mockito.when(dynamicPropertiesStore.getMaintenanceTimeInterval()).thenReturn(600L);
45+
Mockito.when(chainBaseManager.getPbftSignDataStore()).thenReturn(pbftSignDataStore);
46+
47+
Field field = PbftDataSyncHandler.class.getDeclaredField("chainBaseManager");
48+
field.setAccessible(true);
49+
field.set(pbftDataSyncHandler, chainBaseManager);
50+
51+
pbftDataSyncHandler.processPBFTCommitData(blockCapsule);
52+
Field field1 = PbftDataSyncHandler.class.getDeclaredField("pbftCommitMessageCache");
53+
field1.setAccessible(true);
54+
Map map = JSON.parseObject(JSON.toJSONString(field1.get(pbftDataSyncHandler)), Map.class);
55+
Assert.assertFalse(map.containsKey(0));
56+
}
57+
}

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

Lines changed: 121 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,121 @@
1+
package org.tron.core.net.messagehandler;
2+
3+
import static org.mockito.Mockito.mock;
4+
5+
import com.google.protobuf.ByteString;
6+
import java.io.File;
7+
import java.lang.reflect.Field;
8+
import java.net.InetSocketAddress;
9+
import java.util.ArrayList;
10+
import java.util.Collections;
11+
import org.bouncycastle.util.encoders.Hex;
12+
import org.junit.AfterClass;
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.tron.common.application.TronApplicationContext;
19+
import org.tron.common.crypto.SignInterface;
20+
import org.tron.common.crypto.SignUtils;
21+
import org.tron.common.utils.FileUtil;
22+
import org.tron.common.utils.PublicMethod;
23+
import org.tron.common.utils.ReflectUtils;
24+
import org.tron.common.utils.Sha256Hash;
25+
import org.tron.consensus.base.Param;
26+
import org.tron.consensus.pbft.message.PbftMessage;
27+
import org.tron.core.Constant;
28+
import org.tron.core.capsule.BlockCapsule;
29+
import org.tron.core.config.DefaultConfig;
30+
import org.tron.core.config.args.Args;
31+
import org.tron.core.consensus.PbftBaseImpl;
32+
import org.tron.core.exception.P2pException;
33+
import org.tron.core.net.TronNetService;
34+
import org.tron.core.net.message.MessageTypes;
35+
import org.tron.core.net.peer.PeerConnection;
36+
import org.tron.core.net.peer.PeerManager;
37+
import org.tron.p2p.P2pConfig;
38+
import org.tron.p2p.base.Parameter;
39+
import org.tron.p2p.connection.Channel;
40+
import org.tron.protos.Protocol;
41+
42+
43+
public class PbftMsgHandlerTest {
44+
private static TronApplicationContext context;
45+
private PeerConnection peer;
46+
private static String dbPath = "output-pbft-message-handler-test";
47+
48+
49+
@BeforeClass
50+
public static void init() {
51+
Args.setParam(new String[] {"--output-directory", dbPath, "--debug"},
52+
Constant.TEST_CONF);
53+
context = new TronApplicationContext(DefaultConfig.class);
54+
55+
TronNetService tronNetService = context.getBean(TronNetService.class);
56+
Parameter.p2pConfig = new P2pConfig();
57+
ReflectUtils.setFieldValue(tronNetService, "p2pConfig", Parameter.p2pConfig);
58+
}
59+
60+
@AfterClass
61+
public static void destroy() {
62+
Args.clearParam();
63+
context.destroy();
64+
FileUtil.deleteDir(new File(dbPath));
65+
}
66+
67+
@Before
68+
public void clearPeers() {
69+
try {
70+
Field field = PeerManager.class.getDeclaredField("peers");
71+
field.setAccessible(true);
72+
field.set(PeerManager.class, Collections.synchronizedList(new ArrayList<>()));
73+
} catch (NoSuchFieldException | IllegalAccessException e) {
74+
//ignore
75+
}
76+
}
77+
78+
@Test
79+
public void testPbft() throws Exception {
80+
InetSocketAddress a1 = new InetSocketAddress("127.0.0.1", 10001);
81+
Channel c1 = mock(Channel.class);
82+
Mockito.when(c1.getInetSocketAddress()).thenReturn(a1);
83+
Mockito.when(c1.getInetAddress()).thenReturn(a1.getAddress());
84+
PeerManager.add(context, c1);
85+
Assert.assertEquals(1, PeerManager.getPeers().size());
86+
Assert.assertFalse(c1.isDisconnect());
87+
88+
peer = PeerManager.getPeers().get(0);
89+
BlockCapsule blockCapsule = new BlockCapsule(1, Sha256Hash.ZERO_HASH,
90+
System.currentTimeMillis(), ByteString.EMPTY);
91+
PbftMessage pbftMessage = new PbftMessage();
92+
Protocol.PBFTMessage.Raw.Builder rawBuilder = Protocol.PBFTMessage.Raw.newBuilder();
93+
Protocol.PBFTMessage.Builder builder = Protocol.PBFTMessage.newBuilder();
94+
rawBuilder.setViewN(blockCapsule.getNum())
95+
.setEpoch(0)
96+
.setDataType(Protocol.PBFTMessage.DataType.BLOCK)
97+
.setMsgType(Protocol.PBFTMessage.MsgType.PREPREPARE)
98+
.setData(blockCapsule.getBlockId().getByteString());
99+
Protocol.PBFTMessage.Raw raw = rawBuilder.build();
100+
builder.setRawData(raw);
101+
SignInterface sign = SignUtils.fromPrivate(Hex.decode(PublicMethod.getRandomPrivateKey()),
102+
true);
103+
builder.setSignature(ByteString.copyFrom(sign.Base64toBytes(sign.signHash(
104+
Sha256Hash.hash(true, raw.toByteArray())))));
105+
Protocol.PBFTMessage message = builder.build();
106+
pbftMessage.setType(MessageTypes.PBFT_MSG.asByte());
107+
pbftMessage.setPbftMessage(message);
108+
pbftMessage.setData(message.toByteArray());
109+
pbftMessage.setSwitch(blockCapsule.isSwitch());
110+
Param.getInstance().setPbftInterface(context.getBean(PbftBaseImpl.class));
111+
peer.setNeedSyncFromPeer(false);
112+
//Mockito.doNothing().when(pbftMessage).analyzeSignature();
113+
try {
114+
context.getBean(PbftMsgHandler.class).processMessage(peer, pbftMessage);
115+
} catch (P2pException e) {
116+
Assert.assertEquals(P2pException.TypeEnum.BAD_MESSAGE, e.getType());
117+
}
118+
119+
Assert.assertEquals(1, PeerManager.getPeers().size());
120+
}
121+
}

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

Lines changed: 84 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,84 @@
1+
package org.tron.core.net.messagehandler;
2+
3+
import com.google.protobuf.Any;
4+
import com.google.protobuf.ByteString;
5+
import java.lang.reflect.Field;
6+
import java.util.ArrayList;
7+
import java.util.List;
8+
import java.util.Map;
9+
import java.util.concurrent.ConcurrentHashMap;
10+
import org.joda.time.DateTime;
11+
import org.junit.Assert;
12+
import org.junit.BeforeClass;
13+
import org.junit.Test;
14+
import org.mockito.Mockito;
15+
import org.tron.common.BaseTest;
16+
import org.tron.common.utils.ByteArray;
17+
import org.tron.core.Constant;
18+
import org.tron.core.config.args.Args;
19+
import org.tron.core.net.TronNetDelegate;
20+
import org.tron.core.net.message.adv.TransactionMessage;
21+
import org.tron.core.net.message.adv.TransactionsMessage;
22+
import org.tron.core.net.peer.Item;
23+
import org.tron.core.net.peer.PeerConnection;
24+
import org.tron.core.net.service.adv.AdvService;
25+
import org.tron.protos.Protocol;
26+
import org.tron.protos.contract.BalanceContract;
27+
28+
public class TransactionsMsgHandlerTest extends BaseTest {
29+
@BeforeClass
30+
public static void init() {
31+
Args.setParam(new String[]{"--output-directory", dbPath(), "--debug"},
32+
Constant.TEST_CONF);
33+
34+
}
35+
36+
@Test
37+
public void testProcessMessage() {
38+
TransactionsMsgHandler transactionsMsgHandler = new TransactionsMsgHandler();
39+
try {
40+
Assert.assertFalse(transactionsMsgHandler.isBusy());
41+
42+
transactionsMsgHandler.init();
43+
44+
PeerConnection peer = Mockito.mock(PeerConnection.class);
45+
TronNetDelegate tronNetDelegate = Mockito.mock(TronNetDelegate.class);
46+
AdvService advService = Mockito.mock(AdvService.class);
47+
48+
Field field = TransactionsMsgHandler.class.getDeclaredField("tronNetDelegate");
49+
field.setAccessible(true);
50+
field.set(transactionsMsgHandler, tronNetDelegate);
51+
52+
BalanceContract.TransferContract transferContract = BalanceContract.TransferContract
53+
.newBuilder()
54+
.setAmount(10)
55+
.setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString("121212a9cf")))
56+
.setToAddress(ByteString.copyFrom(ByteArray.fromHexString("232323a9cf"))).build();
57+
58+
long transactionTimestamp = DateTime.now().minusDays(4).getMillis();
59+
Protocol.Transaction trx = Protocol.Transaction.newBuilder().setRawData(
60+
Protocol.Transaction.raw.newBuilder().setTimestamp(transactionTimestamp)
61+
.setRefBlockNum(1)
62+
.addContract(
63+
Protocol.Transaction.Contract.newBuilder()
64+
.setType(Protocol.Transaction.Contract.ContractType.TransferContract)
65+
.setParameter(Any.pack(transferContract)).build()).build())
66+
.build();
67+
Map<Item, Long> advInvRequest = new ConcurrentHashMap<>();
68+
Item item = new Item(new TransactionMessage(trx).getMessageId(),
69+
Protocol.Inventory.InventoryType.TRX);
70+
advInvRequest.put(item, 0L);
71+
Mockito.when(peer.getAdvInvRequest()).thenReturn(advInvRequest);
72+
73+
List<Protocol.Transaction> transactionList = new ArrayList<>();
74+
transactionList.add(trx);
75+
transactionsMsgHandler.processMessage(peer, new TransactionsMessage(transactionList));
76+
Assert.assertNull(advInvRequest.get(item));
77+
//Thread.sleep(10);
78+
} catch (Exception e) {
79+
Assert.fail();
80+
} finally {
81+
transactionsMsgHandler.close();
82+
}
83+
}
84+
}

0 commit comments

Comments
 (0)