test(db): add test for db

framework/src/test/java/org/tron/common/storage/leveldb/LevelDbDataSourceImplTest.java

@@ -27,7 +27,9 @@
 import com.google.common.collect.Sets;
 import java.io.File;
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -113,6 +115,13 @@ public void testReset() {
         Args.getInstance().getOutputDirectory(), "test_reset");
     dataSource.resetDb();
     assertEquals(0, dataSource.allKeys().size());
+    assertEquals("LEVELDB", dataSource.getEngine());
+    assertEquals("test_reset", dataSource.getName());
+    assertEquals(Sets.newHashSet(), dataSource.getlatestValues(0));
+    assertEquals(Collections.emptyMap(), dataSource.getNext(key1, 0));
+    assertEquals(new ArrayList<>(), dataSource.getKeysNext(key1, 0));
+    assertEquals(Sets.newHashSet(), dataSource.getValuesNext(key1, 0));
+    assertEquals(Sets.newHashSet(), dataSource.getlatestValues(0));
     dataSource.closeDB();
   }
 

framework/src/test/java/org/tron/common/storage/leveldb/RocksDbDataSourceImplTest.java

@@ -9,7 +9,9 @@
 import com.google.common.collect.Sets;
 import java.io.File;
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -95,6 +97,13 @@ public void testReset() {
         Args.getInstance().getOutputDirectory(), "test_reset");
     dataSource.resetDb();
     assertEquals(0, dataSource.allKeys().size());
+    assertEquals("ROCKSDB", dataSource.getEngine());
+    assertEquals("test_reset", dataSource.getName());
+    assertEquals(Sets.newHashSet(), dataSource.getlatestValues(0));
+    assertEquals(Collections.emptyMap(), dataSource.getNext(key1, 0));
+    assertEquals(new ArrayList<>(), dataSource.getKeysNext(key1, 0));
+    assertEquals(Sets.newHashSet(), dataSource.getValuesNext(key1, 0));
+    assertEquals(Sets.newHashSet(), dataSource.getlatestValues(0));
     dataSource.closeDB();
   }
 

framework/src/test/java/org/tron/core/db/AbiStoreTest.java

@@ -0,0 +1,61 @@
+package org.tron.core.db;
+
+import static org.tron.common.utils.PublicMethod.jsonStr2Abi;
+
+import com.google.protobuf.ByteString;
+import javax.annotation.Resource;
+import org.bouncycastle.util.encoders.Hex;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.tron.common.BaseTest;
+import org.tron.common.utils.ByteArray;
+import org.tron.core.Constant;
+import org.tron.core.capsule.AbiCapsule;
+import org.tron.core.capsule.AccountCapsule;
+import org.tron.core.config.args.Args;
+import org.tron.core.store.AbiStore;
+import org.tron.core.store.AccountIndexStore;
+import org.tron.protos.Protocol.AccountType;
+import org.tron.protos.contract.SmartContractOuterClass;
+
+public class AbiStoreTest extends BaseTest {
+
+  @Resource
+  private AbiStore abiStore;
+
+  private static final byte[] contractAddr = Hex.decode(
+      "41000000000000000000000000000000000000dEaD");
+
+  private static final SmartContractOuterClass.SmartContract.ABI SOURCE_ABI = jsonStr2Abi(
+      "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\""
+          + ":\"constructor\"}]");
+
+  static {
+    Args.setParam(
+        new String[]{
+            "--output-directory", dbPath()
+        },
+        Constant.TEST_CONF
+    );
+  }
+
+  @Test
+  public void testPut() {
+    abiStore.put(contractAddr, new AbiCapsule(SOURCE_ABI));
+    Assert.assertEquals(abiStore.has(contractAddr), Boolean.TRUE);
+  }
+
+  @Test
+  public void testGet() {
+    abiStore.put(contractAddr, new AbiCapsule(SOURCE_ABI));
+    AbiCapsule abiCapsule = abiStore.get(contractAddr);
+    Assert.assertEquals(abiCapsule.getInstance(), SOURCE_ABI);
+  }
+
+  @Test
+  public void testGetTotalAbi() {
+    abiStore.put(contractAddr, new AbiCapsule(SOURCE_ABI));
+    Assert.assertEquals(abiStore.getTotalABIs(), 1);
+  }
+}

framework/src/test/java/org/tron/core/db/AccountTraceStoreTest.java

@@ -0,0 +1,57 @@
+package org.tron.core.db;
+
+import com.google.common.primitives.Bytes;
+import com.google.common.primitives.Longs;
+import com.google.protobuf.ByteString;
+import javax.annotation.Resource;
+import org.apache.commons.lang3.tuple.Pair;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.tron.common.BaseTest;
+import org.tron.common.utils.ByteArray;
+import org.tron.core.Constant;
+import org.tron.core.capsule.AccountCapsule;
+import org.tron.core.config.args.Args;
+import org.tron.core.exception.BadItemException;
+import org.tron.core.exception.ItemNotFoundException;
+import org.tron.core.store.AccountIndexStore;
+import org.tron.core.store.AccountTraceStore;
+import org.tron.protos.Protocol.AccountType;
+
+public class AccountTraceStoreTest extends BaseTest {
+
+  @Resource
+  private AccountTraceStore accountTraceStore;
+  private static byte[] address = TransactionStoreTest.randomBytes(32);
+
+  static {
+    Args.setParam(
+        new String[]{
+            "--output-directory", dbPath()
+        },
+        Constant.TEST_CONF
+    );
+  }
+
+
+  @Test
+  public void testRecordBalanceWithBlock() throws BadItemException, ItemNotFoundException {
+    accountTraceStore.recordBalanceWithBlock(address,1,9999);
+    Assert.assertNotNull(accountTraceStore.get(Bytes.concat(address,
+        Longs.toByteArray(1L ^ Long.MAX_VALUE))));
+  }
+
+  @Test
+  public void testGetPrevBalance() {
+    accountTraceStore.recordBalanceWithBlock(address,2,9999);
+    Pair<Long, Long> pair = accountTraceStore.getPrevBalance(address,2);
+    Assert.assertEquals((long)pair.getKey(),2L);
+    Assert.assertEquals((long)pair.getValue(), 0L);
+    byte[] address2 = TransactionStoreTest.randomBytes(21);
+    accountTraceStore.recordBalanceWithBlock(address2,3,99);
+    Pair<Long,Long> pair2 = accountTraceStore.getPrevBalance(address2, 3);
+    Assert.assertEquals((long)pair2.getKey(),3L);
+    Assert.assertEquals((long)pair2.getValue(), 99L);
+  }
+}

framework/src/test/java/org/tron/core/db/BalanceTraceStoreTest.java

@@ -0,0 +1,131 @@
+package org.tron.core.db;
+
+import static org.junit.Assert.assertEquals;
+import static org.tron.protos.Protocol.Transaction.Contract.ContractType.TransferContract;
+import static org.tron.protos.Protocol.Transaction.Result.contractResult.SUCCESS;
+
+import com.google.protobuf.ByteString;
+import java.util.Arrays;
+import javax.annotation.Resource;
+import org.bouncycastle.util.encoders.Hex;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.tron.common.BaseTest;
+import org.tron.common.utils.ByteArray;
+import org.tron.core.Constant;
+import org.tron.core.capsule.BlockBalanceTraceCapsule;
+import org.tron.core.capsule.BlockCapsule;
+import org.tron.core.capsule.TransactionCapsule;
+import org.tron.core.config.args.Args;
+import org.tron.core.store.BalanceTraceStore;
+import org.tron.protos.Protocol;
+import org.tron.protos.contract.BalanceContract;
+
+
+public class BalanceTraceStoreTest extends BaseTest {
+
+  @Resource
+  private BalanceTraceStore balanceTraceStoreUnderTest;
+
+  private static final byte[] contractAddr = Hex.decode(
+      "41000000000000000000000000000000000000dEaD");
+
+  BlockCapsule blockCapsule = new BlockCapsule(Protocol.Block.newBuilder().setBlockHeader(
+      Protocol.BlockHeader.newBuilder().setRawData(Protocol.BlockHeader.raw.newBuilder()
+          .setParentHash(ByteString.copyFrom(ByteArray.fromHexString(
+              "0304f784e4e7bae517bcab94c3e0c9214fb4ac7ff9d7d5a937d1f40031f87b81"))))).build());
+  final TransactionCapsule transactionCapsule =
+      new TransactionCapsule(Protocol.Transaction.newBuilder().build());
+  BalanceContract.TransactionBalanceTrace transactionBalanceTrace =
+      BalanceContract.TransactionBalanceTrace.newBuilder()
+          .setTransactionIdentifier(transactionCapsule.getTransactionId().getByteString())
+          .setType(TransferContract.name())
+          .setStatus(SUCCESS.name())
+          .build();
+
+  static {
+    Args.setParam(
+        new String[]{
+            "--output-directory", dbPath()
+        },
+        Constant.TEST_CONF
+    );
+  }
+
+  @Before
+  public void clear() {
+    balanceTraceStoreUnderTest.resetCurrentTransactionTrace();
+    balanceTraceStoreUnderTest.resetCurrentBlockTrace();
+  }
+
+
+  @Test
+  public void testSetCurrentTransactionId() throws Exception {
+    balanceTraceStoreUnderTest.setCurrentBlockId(blockCapsule);
+    balanceTraceStoreUnderTest.setCurrentTransactionId(transactionCapsule);
+    Assert.assertEquals(balanceTraceStoreUnderTest.getCurrentTransactionId(),
+        transactionCapsule.getTransactionId());
+  }
+
+  @Test
+  public void testSetCurrentBlockId() {
+    balanceTraceStoreUnderTest.setCurrentBlockId(blockCapsule);
+    Assert.assertEquals(blockCapsule.getBlockId(), balanceTraceStoreUnderTest.getCurrentBlockId());
+  }
+
+  @Test
+  public void testResetCurrentTransactionTrace() {
+    balanceTraceStoreUnderTest.setCurrentBlockId(blockCapsule);
+    balanceTraceStoreUnderTest.setCurrentTransactionId(transactionCapsule);
+    balanceTraceStoreUnderTest.resetCurrentTransactionTrace();
+    balanceTraceStoreUnderTest.resetCurrentBlockTrace();
+    Assert.assertNotNull(balanceTraceStoreUnderTest.getCurrentTransactionId());
+    Assert.assertNull(balanceTraceStoreUnderTest.getCurrentTransactionBalanceTrace());
+  }
+
+  @Test
+  public void testInitCurrentBlockBalanceTrace() {
+    balanceTraceStoreUnderTest.initCurrentBlockBalanceTrace(blockCapsule);
+    Assert.assertNull(balanceTraceStoreUnderTest.getCurrentBlockId());
+  }
+
+  @Test
+  public void testInitCurrentTransactionBalanceTrace() {
+    balanceTraceStoreUnderTest.setCurrentBlockId(blockCapsule);
+    balanceTraceStoreUnderTest.initCurrentTransactionBalanceTrace(transactionCapsule);
+    Assert.assertEquals(blockCapsule.getBlockId(), balanceTraceStoreUnderTest.getCurrentBlockId());
+    Assert.assertNull(balanceTraceStoreUnderTest.getCurrentTransactionId());
+  }
+
+  @Test
+  public void testUpdateCurrentTransactionStatus() {
+    balanceTraceStoreUnderTest.setCurrentBlockId(blockCapsule);
+    balanceTraceStoreUnderTest.updateCurrentTransactionStatus("");
+    Assert.assertNull(balanceTraceStoreUnderTest.getCurrentTransactionBalanceTrace());
+  }
+
+  @Test
+  public void testGetBlockBalanceTrace() throws Exception {
+    BlockBalanceTraceCapsule blockBalanceTraceCapsule = new BlockBalanceTraceCapsule(blockCapsule);
+    balanceTraceStoreUnderTest.put(ByteArray.fromLong(blockCapsule.getNum()),
+        blockBalanceTraceCapsule);
+    final BlockBalanceTraceCapsule result =
+        balanceTraceStoreUnderTest.getBlockBalanceTrace(blockCapsule.getBlockId());
+    assertEquals(Arrays.toString(result.getData()),
+        Arrays.toString(blockBalanceTraceCapsule.getData()));
+  }
+
+  @Test
+  public void testGetTransactionBalanceTrace() throws Exception {
+    BlockBalanceTraceCapsule blockBalanceTraceCapsule = new BlockBalanceTraceCapsule(blockCapsule);
+    blockBalanceTraceCapsule.addTransactionBalanceTrace(transactionBalanceTrace);
+    balanceTraceStoreUnderTest.put(ByteArray.fromLong(blockCapsule.getNum()),
+        blockBalanceTraceCapsule);
+    final BalanceContract.TransactionBalanceTrace result =
+        balanceTraceStoreUnderTest.getTransactionBalanceTrace(blockCapsule.getBlockId(),
+            transactionCapsule.getTransactionId());
+    Assert.assertEquals(result.getStatus(),"SUCCESS");
+  }
+
+}

framework/src/test/java/org/tron/core/db/CodeStoreTest.java

@@ -0,0 +1,74 @@
+package org.tron.core.db;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import javax.annotation.Resource;
+import org.bouncycastle.util.encoders.Hex;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.tron.common.BaseTest;
+import org.tron.common.utils.ByteArray;
+import org.tron.core.Constant;
+import org.tron.core.capsule.CodeCapsule;
+import org.tron.core.config.args.Args;
+import org.tron.core.store.CodeStore;
+
+public class CodeStoreTest extends BaseTest {
+
+  private static final byte[] contractAddr1 = Hex.decode(
+      "41000000000000000000000000000000000000dEaD");
+  private static final byte[] contractAddr2 = Hex.decode(
+      "41000000000000000000000000000000000000dEbD");
+  private static final byte[] contractAddr3 = Hex.decode(
+      "41000000000000000000000000000000000000dEcD");
+
+  private static String codeString =
+      "608060405234801561001057600080fd5b50d3801561001d57600080fd5b50d28015"
+      + "61002a57600080fd5b50600436106100495760003560e01c806385bb7d69146100555761004a565b5b61"
+      + "0052610073565b50005b61005d610073565b60405161006a91906100b9565b60405180910390f35b6000"
+      + "80600090505b60028110156100a657808261009091906100d4565b915060018161009f91906100d4565b"
+      + "905061007b565b5090565b6100b38161012a565b82525050565b60006020820190506100ce6000830184"
+      + "6100aa565b92915050565b60006100df8261012a565b91506100ea8361012a565b9250827fffffffffff"
+      + "ffffffffffffffffffffffffffffffffffffffffffffffffffffff0382111561011f5761011e61013456"
+      + "5b5b828201905092915050565b6000819050919050565b7f4e487b710000000000000000000000000000"
+      + "0000000000000000000000000000600052601160045260246000fdfea26474726f6e58221220f3d01983"
+      + "23c67293b97323c101e294e6d2cac7fb29555292675277e11c275a4b64736f6c63430008060033";
+  private static final CodeCapsule codeCapsule = new CodeCapsule(ByteArray
+      .fromHexString(codeString));
+
+  @Resource
+  private CodeStore codeStore;
+
+  static {
+    Args.setParam(
+        new String[]{
+            "--output-directory", dbPath()
+        },
+        Constant.TEST_CONF
+    );
+  }
+
+  @Test
+  public void testGet() {
+    codeStore.put(contractAddr1, codeCapsule);
+    final CodeCapsule result = codeStore.get(contractAddr1);
+    assertEquals(result.toString(), Arrays.toString(ByteArray.fromHexString(codeString)));
+  }
+
+  @Test
+  public void testGetTotalCodes() throws Exception {
+    codeStore.put(contractAddr1, codeCapsule);
+    codeStore.put(codeCapsule.getCodeHash().getBytes(), codeCapsule);
+    final long result = codeStore.getTotalCodes();
+    assertEquals(2L, result);
+  }
+
+  @Test
+  public void testFindCodeByHash() {
+    codeStore.put(codeCapsule.getCodeHash().getBytes(), codeCapsule);
+    final byte[] result = codeStore.findCodeByHash(codeCapsule.getCodeHash().getBytes());
+    assertEquals(Arrays.toString(result), Arrays.toString(ByteArray.fromHexString(codeString)));
+  }
+}