Skip to content

Commit fcdfeb5

Browse files
Federico2014Federico2014
committed
add the test unit
1 parent a28e337 commit fcdfeb5

4 files changed

Lines changed: 268 additions & 2 deletions

File tree

‎framework/src/main/java/org/tron/core/config/args/WitnessInitializer.java‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -26,11 +26,10 @@ public class WitnessInitializer {
2626

2727
public WitnessInitializer(Config config) {
2828
this.config = config;
29+
this.localWitnesses = new LocalWitnesses();
2930
}
3031

3132
public LocalWitnesses initLocalWitnesses() {
32-
localWitnesses = new LocalWitnesses();
33-
3433
if (!Args.PARAMETER.isWitness()) {
3534
return localWitnesses;
3635
}

‎framework/src/test/java/org/tron/common/crypto/ECKeyTest.java‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@
55
import static org.junit.Assert.assertFalse;
66
import static org.junit.Assert.assertNotEquals;
77
import static org.junit.Assert.assertNotNull;
8+
import static org.junit.Assert.assertNull;
89
import static org.junit.Assert.assertTrue;
910
import static org.junit.Assert.fail;
1011
import static org.tron.common.utils.client.utils.AbiUtil.generateOccupationConstantPrivateKey;
@@ -67,6 +68,11 @@ public void testFromPrivateKey() {
6768
assertTrue(key.isPubKeyCanonical());
6869
assertTrue(key.hasPrivKey());
6970
assertArrayEquals(pubKey, key.getPubKey());
71+
72+
key = ECKey.fromPrivate((byte[]) null);
73+
assertNull(key);
74+
key = ECKey.fromPrivate(new byte[0]);
75+
assertNull(key);
7076
}
7177

7278
@Test(expected = IllegalArgumentException.class)

‎framework/src/test/java/org/tron/common/crypto/SM2KeyTest.java‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@
44
import static org.junit.Assert.assertEquals;
55
import static org.junit.Assert.assertFalse;
66
import static org.junit.Assert.assertNotNull;
7+
import static org.junit.Assert.assertNull;
78
import static org.junit.Assert.assertTrue;
89
import static org.junit.Assert.fail;
910
import static org.tron.common.utils.client.utils.AbiUtil.generateOccupationConstantPrivateKey;
@@ -64,6 +65,11 @@ public void testFromPrivateKey() {
6465
assertTrue(key.isPubKeyCanonical());
6566
assertTrue(key.hasPrivKey());
6667
assertArrayEquals(pubKey, key.getPubKey());
68+
69+
key = SM2.fromPrivate((byte[]) null);
70+
assertNull(key);
71+
key = SM2.fromPrivate(new byte[0]);
72+
assertNull(key);
6773
}
6874

6975
@Test(expected = IllegalArgumentException.class)

‎framework/src/test/java/org/tron/core/config/args/WitnessInitializerTest.java‎

Lines changed: 255 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,255 @@
1+
package org.tron.core.config.args;
2+
3+
import com.typesafe.config.Config;
4+
import com.typesafe.config.ConfigFactory;
5+
import java.io.File;
6+
import java.io.IOException;
7+
import java.lang.reflect.Field;
8+
import java.lang.reflect.InvocationTargetException;
9+
import java.lang.reflect.Method;
10+
import java.util.ArrayList;
11+
import java.util.List;
12+
import org.junit.After;
13+
import org.junit.Before;
14+
import org.junit.Test;
15+
import org.tron.common.crypto.SignInterface;
16+
import org.tron.common.parameter.CommonParameter;
17+
import org.tron.common.utils.ByteArray;
18+
import org.tron.common.utils.LocalWitnesses;
19+
import org.tron.common.utils.PublicMethod;
20+
import org.tron.common.utils.client.utils.Base58;
21+
import org.tron.core.Constant;
22+
import org.tron.core.exception.CipherException;
23+
import org.tron.core.exception.TronError;
24+
25+
import org.tron.core.exception.TronError.ErrCode;
26+
import org.tron.keystore.Credentials;
27+
import org.tron.keystore.WalletUtils;
28+
29+
import static org.junit.Assert.*;
30+
import static org.mockito.Mockito.*;
31+
32+
public class WitnessInitializerTest {
33+
34+
private Config config;
35+
private WitnessInitializer witnessInitializer;
36+
37+
private static final String privateKey = PublicMethod.getRandomPrivateKey();
38+
private static final String address = Base58.encode58Check(
39+
ByteArray.fromHexString(PublicMethod.getHexAddressByPrivateKey(privateKey)));
40+
private static final String invalidAddress = "RJCzdnv88Hvqa2jB1C9dMmMYHr5DFdF2R3";
41+
42+
@Before
43+
public void setUp() {
44+
config = ConfigFactory.empty();
45+
witnessInitializer = new WitnessInitializer(config);
46+
}
47+
48+
@After
49+
public void clear() {
50+
Args.clearParam();
51+
}
52+
53+
@Test
54+
public void testInitLocalWitnessesEmpty() {
55+
Args.PARAMETER.setWitness(false);
56+
57+
LocalWitnesses result = witnessInitializer.initLocalWitnesses();
58+
assertNotNull(result);
59+
assertTrue(result.getPrivateKeys().isEmpty());
60+
61+
Args.PARAMETER.setWitness(true);
62+
LocalWitnesses localWitnesses = witnessInitializer.initLocalWitnesses();
63+
assertTrue(localWitnesses.getPrivateKeys().isEmpty());
64+
65+
String configString = "localwitness = [] \n localwitnesskeystore = []";
66+
config = ConfigFactory.parseString(configString);
67+
witnessInitializer = new WitnessInitializer(config);
68+
localWitnesses = witnessInitializer.initLocalWitnesses();
69+
assertTrue(localWitnesses.getPrivateKeys().isEmpty());
70+
}
71+
72+
@Test
73+
public void testTryInitFromCommandLine()
74+
throws NoSuchFieldException, IllegalAccessException, NoSuchMethodException,
75+
InvocationTargetException {
76+
Field privateKeyField = CommonParameter.class.getDeclaredField("privateKey");
77+
privateKeyField.setAccessible(true);
78+
privateKeyField.set(Args.getInstance(), "");
79+
80+
witnessInitializer = new WitnessInitializer(config);
81+
Method method = WitnessInitializer.class.getDeclaredMethod(
82+
"tryInitFromCommandLine");
83+
method.setAccessible(true);
84+
boolean result = (boolean) method.invoke(witnessInitializer);
85+
assertFalse(result);
86+
87+
privateKeyField.set(Args.getInstance(), privateKey);
88+
method.invoke(witnessInitializer);
89+
result = (boolean) method.invoke(witnessInitializer);
90+
assertTrue(result);
91+
92+
Field witnessAddress = CommonParameter.class.getDeclaredField("witnessAddress");
93+
witnessAddress.setAccessible(true);
94+
witnessAddress.set(Args.getInstance(), address);
95+
result = (boolean) method.invoke(witnessInitializer);
96+
assertTrue(result);
97+
98+
witnessAddress.set(Args.getInstance(), invalidAddress);
99+
InvocationTargetException thrown = assertThrows(InvocationTargetException.class,
100+
() -> method.invoke(witnessInitializer));
101+
TronError targetException = (TronError) thrown.getTargetException();
102+
assertEquals(ErrCode.WITNESS_INIT, targetException.getErrCode());
103+
}
104+
105+
@Test
106+
public void testTryInitFromConfig()
107+
throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
108+
witnessInitializer = new WitnessInitializer(config);
109+
Method method = WitnessInitializer.class.getDeclaredMethod(
110+
"tryInitFromConfig");
111+
method.setAccessible(true);
112+
boolean result = (boolean) method.invoke(witnessInitializer);
113+
assertFalse(result);
114+
115+
String configString = "localwitness = []";
116+
config = ConfigFactory.parseString(configString);
117+
witnessInitializer = new WitnessInitializer(config);
118+
result = (boolean) method.invoke(witnessInitializer);
119+
assertFalse(result);
120+
121+
configString = "localwitness = [" + privateKey + "]";
122+
config = ConfigFactory.parseString(configString);
123+
witnessInitializer = new WitnessInitializer(config);
124+
result = (boolean) method.invoke(witnessInitializer);
125+
assertTrue(result);
126+
127+
configString = "localWitnessAccountAddress = " + address + "\n" +
128+
"localwitness = [\n" + privateKey + "]";
129+
config = ConfigFactory.parseString(configString);
130+
witnessInitializer = new WitnessInitializer(config);
131+
result = (boolean) method.invoke(witnessInitializer);
132+
assertTrue(result);
133+
134+
configString = "localwitness = [\n" + privateKey + "\n" + privateKey + "]";
135+
config = ConfigFactory.parseString(configString);
136+
witnessInitializer = new WitnessInitializer(config);
137+
result = (boolean) method.invoke(witnessInitializer);
138+
assertTrue(result);
139+
140+
configString = "localWitnessAccountAddress = " + invalidAddress + "\n" +
141+
"localwitness = [\n" + privateKey + "]";
142+
config = ConfigFactory.parseString(configString);
143+
witnessInitializer = new WitnessInitializer(config);
144+
InvocationTargetException thrown = assertThrows(InvocationTargetException.class,
145+
() -> method.invoke(witnessInitializer));
146+
TronError targetException = (TronError) thrown.getTargetException();
147+
assertEquals(ErrCode.WITNESS_INIT, targetException.getErrCode());
148+
149+
configString = "localWitnessAccountAddress = " + address + "\n" +
150+
"localwitness = [\n" + privateKey + "\n" + privateKey + "]";
151+
config = ConfigFactory.parseString(configString);
152+
witnessInitializer = new WitnessInitializer(config);
153+
thrown = assertThrows(InvocationTargetException.class,
154+
() -> method.invoke(witnessInitializer));
155+
targetException = (TronError) thrown.getTargetException();
156+
assertEquals(ErrCode.WITNESS_INIT, targetException.getErrCode());
157+
}
158+
159+
@Test
160+
public void testTryInitFromKeystore()
161+
throws NoSuchMethodException, InvocationTargetException, IllegalAccessException,
162+
NoSuchFieldException {
163+
witnessInitializer = new WitnessInitializer(config);
164+
Method method = WitnessInitializer.class.getDeclaredMethod(
165+
"tryInitFromKeystore");
166+
method.setAccessible(true);
167+
method.invoke(witnessInitializer);
168+
Field localWitnessField = WitnessInitializer.class.getDeclaredField("localWitnesses");
169+
localWitnessField.setAccessible(true);
170+
LocalWitnesses localWitnesses = (LocalWitnesses) localWitnessField.get(witnessInitializer);
171+
assertTrue(localWitnesses.getPrivateKeys().isEmpty());
172+
173+
String configString = "localwitnesskeystore = []";
174+
Config emptyListConfig = ConfigFactory.parseString(configString);
175+
witnessInitializer = new WitnessInitializer(emptyListConfig);
176+
method.invoke(witnessInitializer);
177+
localWitnesses = (LocalWitnesses) localWitnessField.get(witnessInitializer);
178+
assertTrue(localWitnesses.getPrivateKeys().isEmpty());
179+
}
180+
181+
@Test
182+
public void testTryInitFromKeyStore2()
183+
throws CipherException, IOException, NoSuchFieldException, IllegalAccessException {
184+
Args.PARAMETER.setWitness(true);
185+
Config mockConfig = mock(Config.class);
186+
when(mockConfig.hasPath(Constant.LOCAL_WITNESS_KEYSTORE)).thenReturn(false);
187+
witnessInitializer = new WitnessInitializer(mockConfig);
188+
witnessInitializer.initLocalWitnesses();
189+
verify(mockConfig, never()).getStringList(anyString());
190+
191+
when(mockConfig.hasPath(Constant.LOCAL_WITNESS_KEYSTORE)).thenReturn(true);
192+
when(mockConfig.getStringList(Constant.LOCAL_WITNESS_KEYSTORE)).thenReturn(new ArrayList<>());
193+
witnessInitializer = new WitnessInitializer(mockConfig);
194+
witnessInitializer.initLocalWitnesses();
195+
verify(mockConfig, times(1)).getStringList(Constant.LOCAL_WITNESS_KEYSTORE);
196+
197+
List<String> keystores = new ArrayList<>();
198+
keystores.add("keystore1.json");
199+
keystores.add("keystore2.json");
200+
when(mockConfig.hasPath(Constant.LOCAL_WITNESS_KEYSTORE)).thenReturn(true);
201+
when(mockConfig.getStringList(Constant.LOCAL_WITNESS_KEYSTORE)).thenReturn(keystores);
202+
203+
Field password = CommonParameter.class.getDeclaredField("password");
204+
password.setAccessible(true);
205+
password.set(Args.getInstance(), "password");
206+
207+
// Mock WalletUtils.loadCredentials
208+
Credentials credentials = mock(Credentials.class);
209+
SignInterface signInterface = mock(SignInterface.class);
210+
when(credentials.getSignInterface()).thenReturn(signInterface);
211+
byte[] keyBytes = ByteArray.fromHexString(privateKey);
212+
when(signInterface.getPrivateKey()).thenReturn(keyBytes);
213+
mockStatic(WalletUtils.class);
214+
when(WalletUtils.loadCredentials(anyString(), any(File.class))).thenReturn(credentials);
215+
216+
// Mock ByteArray.toHexString
217+
mockStatic(ByteArray.class);
218+
when(ByteArray.toHexString(any(byte[].class))).thenReturn(privateKey);
219+
when(ByteArray.fromHexString(any())).thenReturn(keyBytes);
220+
221+
witnessInitializer = new WitnessInitializer(mockConfig);
222+
LocalWitnesses localWitnesses = witnessInitializer.initLocalWitnesses();
223+
assertFalse(localWitnesses.getPrivateKeys().isEmpty());
224+
}
225+
226+
227+
@Test
228+
public void testGetWitnessAddress()
229+
throws InvocationTargetException, IllegalAccessException, NoSuchMethodException,
230+
NoSuchFieldException {
231+
witnessInitializer = new WitnessInitializer(config);
232+
Method method = WitnessInitializer.class.getDeclaredMethod(
233+
"getWitnessAddress");
234+
method.setAccessible(true);
235+
byte[] result = (byte[]) method.invoke(witnessInitializer);
236+
assertNull(result);
237+
238+
String configString = "localWitnessAccountAddress = " + address;
239+
config = ConfigFactory.parseString(configString);
240+
witnessInitializer = new WitnessInitializer(config);
241+
Field localWitnessField = WitnessInitializer.class.getDeclaredField("localWitnesses");
242+
localWitnessField.setAccessible(true);
243+
localWitnessField.set(witnessInitializer, new LocalWitnesses(privateKey));
244+
result = (byte[]) method.invoke(witnessInitializer);
245+
assertNotNull(result);
246+
247+
configString = "localWitnessAccountAddress = " + invalidAddress;
248+
config = ConfigFactory.parseString(configString);
249+
witnessInitializer = new WitnessInitializer(config);
250+
InvocationTargetException thrown = assertThrows(InvocationTargetException.class,
251+
() -> method.invoke(witnessInitializer));
252+
TronError targetException = (TronError) thrown.getTargetException();
253+
assertEquals(ErrCode.WITNESS_INIT, targetException.getErrCode());
254+
}
255+
}

0 commit comments

Comments
 (0)