From bc8e8df2b5bf683334a84e28fe1f18bc5e8249a8 Mon Sep 17 00:00:00 2001 From: "morgan.peng" Date: Thu, 17 Aug 2023 23:19:50 +0800 Subject: [PATCH] feat(test): add db test --- .../leveldb/LevelDbDataSourceImplTest.java | 9 ++ .../leveldb/RocksDbDataSourceImplTest.java | 9 ++ .../java/org/tron/core/db/AbiStoreTest.java | 61 +++++++ .../tron/core/db/AccountTraceStoreTest.java | 57 +++++++ .../org/tron/core/db/AssetIssueStoreTest.java | 80 ++++++++++ .../tron/core/db/BalanceTraceStoreTest.java | 131 +++++++++++++++ .../java/org/tron/core/db/CodeStoreTest.java | 74 +++++++++ ...elegatedResourceAccountIndexStoreTest.java | 150 ++++++++++++++++++ 8 files changed, 571 insertions(+) create mode 100644 framework/src/test/java/org/tron/core/db/AbiStoreTest.java create mode 100644 framework/src/test/java/org/tron/core/db/AccountTraceStoreTest.java create mode 100644 framework/src/test/java/org/tron/core/db/AssetIssueStoreTest.java create mode 100644 framework/src/test/java/org/tron/core/db/BalanceTraceStoreTest.java create mode 100644 framework/src/test/java/org/tron/core/db/CodeStoreTest.java create mode 100644 framework/src/test/java/org/tron/core/db/DelegatedResourceAccountIndexStoreTest.java diff --git a/framework/src/test/java/org/tron/common/storage/leveldb/LevelDbDataSourceImplTest.java b/framework/src/test/java/org/tron/common/storage/leveldb/LevelDbDataSourceImplTest.java index c774d10c172..50a55d24a0f 100644 --- a/framework/src/test/java/org/tron/common/storage/leveldb/LevelDbDataSourceImplTest.java +++ b/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(); } diff --git a/framework/src/test/java/org/tron/common/storage/leveldb/RocksDbDataSourceImplTest.java b/framework/src/test/java/org/tron/common/storage/leveldb/RocksDbDataSourceImplTest.java index 51a5ddc96ee..ed37c1e4bcd 100644 --- a/framework/src/test/java/org/tron/common/storage/leveldb/RocksDbDataSourceImplTest.java +++ b/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(); } diff --git a/framework/src/test/java/org/tron/core/db/AbiStoreTest.java b/framework/src/test/java/org/tron/core/db/AbiStoreTest.java new file mode 100644 index 00000000000..0cb134c50ce --- /dev/null +++ b/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); + } +} \ No newline at end of file diff --git a/framework/src/test/java/org/tron/core/db/AccountTraceStoreTest.java b/framework/src/test/java/org/tron/core/db/AccountTraceStoreTest.java new file mode 100644 index 00000000000..aa87f903ad3 --- /dev/null +++ b/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 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 pair2 = accountTraceStore.getPrevBalance(address2, 3); + Assert.assertEquals((long)pair2.getKey(),3L); + Assert.assertEquals((long)pair2.getValue(), 99L); + } +} \ No newline at end of file diff --git a/framework/src/test/java/org/tron/core/db/AssetIssueStoreTest.java b/framework/src/test/java/org/tron/core/db/AssetIssueStoreTest.java new file mode 100644 index 00000000000..3dbde0380c0 --- /dev/null +++ b/framework/src/test/java/org/tron/core/db/AssetIssueStoreTest.java @@ -0,0 +1,80 @@ +package org.tron.core.db; + +import com.google.protobuf.ByteString; +import java.util.List; +import javax.annotation.Resource; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.tron.common.BaseTest; +import org.tron.core.Constant; +import org.tron.core.capsule.AssetIssueCapsule; +import org.tron.core.config.args.Args; +import org.tron.core.store.AssetIssueStore; +import org.tron.protos.contract.AssetIssueContractOuterClass; + +public class AssetIssueStoreTest extends BaseTest { + + @Resource + private AssetIssueStore assetIssueStore; + + private static String tokenId1 = "tokenId1"; + private static String tokenId2 = "tokenId2"; + private static AssetIssueContractOuterClass.AssetIssueContract assetIssueContract1 = + AssetIssueContractOuterClass.AssetIssueContract.newBuilder().setId(String.valueOf(1)) + .setName(ByteString.copyFrom(tokenId1.getBytes())).setFreeAssetNetLimit(100) + .setTrxNum(888).build(); + private static AssetIssueContractOuterClass.AssetIssueContract assetIssueContract2 = + AssetIssueContractOuterClass.AssetIssueContract.newBuilder().setId(String.valueOf(2)) + .setName(ByteString.copyFrom(tokenId2.getBytes())).setFreeAssetNetLimit(1000) + .setTrxNum(8880).build(); + + static { + Args.setParam( + new String[]{ + "--output-directory", dbPath() + }, + Constant.TEST_CONF + ); + } + + @Before + public void init() { + AssetIssueCapsule assetIssueCapsule1 = new AssetIssueCapsule(assetIssueContract1); + AssetIssueCapsule assetIssueCapsule2 = new AssetIssueCapsule(assetIssueContract2); + assetIssueStore.put(assetIssueCapsule1.getName().toByteArray(), assetIssueCapsule1); + assetIssueStore.put(assetIssueCapsule2.getName().toByteArray(), assetIssueCapsule2); + } + + @Test + public void testGet() { + AssetIssueCapsule assetIssueCapsule = assetIssueStore.get(tokenId1.getBytes()); + Assert.assertEquals(assetIssueCapsule.getId(), String.valueOf(1)); + Assert.assertEquals(assetIssueCapsule.getTrxNum(), 888); + Assert.assertEquals(assetIssueCapsule.getFreeAssetNetLimit(), 100); + Assert.assertEquals(assetIssueCapsule.getName(), ByteString.copyFrom(tokenId1.getBytes())); + AssetIssueCapsule assetIssueCapsule2 = assetIssueStore.get(tokenId2.getBytes()); + Assert.assertEquals(assetIssueCapsule2.getId(), String.valueOf(2)); + Assert.assertEquals(assetIssueCapsule2.getTrxNum(), 8880); + Assert.assertEquals(assetIssueCapsule2.getFreeAssetNetLimit(), 1000); + Assert.assertEquals(assetIssueCapsule2.getName(), ByteString.copyFrom(tokenId2.getBytes())); + } + + @Test + public void testGetAllAssetIssues() { + List assetIssueCapsules = assetIssueStore.getAllAssetIssues(); + Assert.assertEquals(assetIssueCapsules.size(), 2); + } + + @Test + public void testGetAssetIssuesPaginated() { + List assetIssueCapsules = assetIssueStore.getAssetIssuesPaginated( + 1,1); + Assert.assertEquals(assetIssueCapsules.size(), 1); + AssetIssueCapsule assetIssueCapsule2 = assetIssueCapsules.get(0); + Assert.assertEquals(assetIssueCapsule2.getId(), String.valueOf(2)); + Assert.assertEquals(assetIssueCapsule2.getTrxNum(), 8880); + Assert.assertEquals(assetIssueCapsule2.getFreeAssetNetLimit(), 1000); + Assert.assertEquals(assetIssueCapsule2.getName(), ByteString.copyFrom(tokenId2.getBytes())); + } +} \ No newline at end of file diff --git a/framework/src/test/java/org/tron/core/db/BalanceTraceStoreTest.java b/framework/src/test/java/org/tron/core/db/BalanceTraceStoreTest.java new file mode 100644 index 00000000000..82547a997da --- /dev/null +++ b/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"); + } + +} \ No newline at end of file diff --git a/framework/src/test/java/org/tron/core/db/CodeStoreTest.java b/framework/src/test/java/org/tron/core/db/CodeStoreTest.java new file mode 100644 index 00000000000..59bfba2236a --- /dev/null +++ b/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))); + } +} \ No newline at end of file diff --git a/framework/src/test/java/org/tron/core/db/DelegatedResourceAccountIndexStoreTest.java b/framework/src/test/java/org/tron/core/db/DelegatedResourceAccountIndexStoreTest.java new file mode 100644 index 00000000000..fd5932603e3 --- /dev/null +++ b/framework/src/test/java/org/tron/core/db/DelegatedResourceAccountIndexStoreTest.java @@ -0,0 +1,150 @@ +package org.tron.core.db; + +import com.google.common.primitives.Bytes; +import com.google.protobuf.ByteString; +import java.util.Collections; +import javax.annotation.Resource; +import org.junit.Assert; +import org.junit.Test; +import org.tron.common.BaseTest; +import org.tron.common.utils.ByteArray; +import org.tron.common.utils.DecodeUtil; +import org.tron.core.Constant; +import org.tron.core.capsule.DelegatedResourceAccountIndexCapsule; +import org.tron.core.config.args.Args; +import org.tron.core.store.DelegatedResourceAccountIndexStore; + + +public class DelegatedResourceAccountIndexStoreTest extends BaseTest { + + @Resource + private DelegatedResourceAccountIndexStore delegatedResourceAccountIndexStore; + + String owner1 = DecodeUtil.addressPreFixString + "548794500882809695a8a687866e76d4271a1abc"; + private static final byte[] FROM_PREFIX = {0x01}; + private static final byte[] TO_PREFIX = {0x02}; + private static final byte[] V2_FROM_PREFIX = {0x03}; + private static final byte[] V2_TO_PREFIX = {0x04}; + + static { + Args.setParam( + new String[]{ + "--output-directory", dbPath() + }, + Constant.TEST_CONF + ); + } + + @Test + public void testGet() { + delegatedResourceAccountIndexStore.put(ByteArray.fromHexString(owner1), + new DelegatedResourceAccountIndexCapsule(ByteString.copyFrom("testGet".getBytes()))); + final DelegatedResourceAccountIndexCapsule result = + delegatedResourceAccountIndexStore.get(ByteArray.fromHexString(owner1)); + Assert.assertNotNull(result); + Assert.assertEquals(result.getAccount(), ByteString.copyFrom("testGet".getBytes())); + } + + @Test + public void testConvert() { + DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule = + new DelegatedResourceAccountIndexCapsule(ByteString.copyFrom("testConvert".getBytes())); + delegatedResourceAccountIndexCapsule.setAllFromAccounts( + Collections.singletonList(ByteString.copyFrom("testConvertFrom".getBytes()))); + delegatedResourceAccountIndexCapsule.setAllToAccounts( + Collections.singletonList(ByteString.copyFrom("testConvertTo".getBytes()))); + delegatedResourceAccountIndexStore.put(ByteArray.fromHexString(owner1), + delegatedResourceAccountIndexCapsule); + delegatedResourceAccountIndexStore.convert(ByteArray.fromHexString(owner1)); + DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule1 = + delegatedResourceAccountIndexStore.get(Bytes.concat(FROM_PREFIX, + ByteArray.fromHexString(owner1), "testConvertTo".getBytes())); + DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule2 = + delegatedResourceAccountIndexStore.get(Bytes.concat(TO_PREFIX, + "testConvertTo".getBytes(), ByteArray.fromHexString(owner1))); + Assert.assertNotNull(delegatedResourceAccountIndexCapsule1); + Assert.assertNotNull(delegatedResourceAccountIndexCapsule2); + } + + @Test + public void testDelegate() throws Exception { + delegatedResourceAccountIndexStore.delegate("testDelegateFrom".getBytes(), + "testDelegateTo".getBytes(),1L); + DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule1 = + delegatedResourceAccountIndexStore.get(Bytes.concat(FROM_PREFIX, + "testDelegateFrom".getBytes(), "testDelegateTo".getBytes())); + DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule2 = + delegatedResourceAccountIndexStore.get(Bytes.concat(TO_PREFIX, "testDelegateTo".getBytes(), + "testDelegateFrom".getBytes())); + Assert.assertNotNull(delegatedResourceAccountIndexCapsule1); + Assert.assertEquals(delegatedResourceAccountIndexCapsule1.getTimestamp(),1); + Assert.assertNotNull(delegatedResourceAccountIndexCapsule2); + Assert.assertEquals(delegatedResourceAccountIndexCapsule2.getTimestamp(),1); + } + + @Test + public void testDelegateV2() { + delegatedResourceAccountIndexStore.delegateV2("testDelegatev2From".getBytes(), + "testDelegatev2To".getBytes(),2L); + DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule1 = + delegatedResourceAccountIndexStore.get(Bytes.concat(V2_FROM_PREFIX, + "testDelegatev2From".getBytes(), "testDelegatev2To".getBytes())); + DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule2 = + delegatedResourceAccountIndexStore.get(Bytes.concat(V2_TO_PREFIX, + "testDelegatev2To".getBytes(), "testDelegatev2From".getBytes())); + Assert.assertNotNull(delegatedResourceAccountIndexCapsule1); + Assert.assertEquals(delegatedResourceAccountIndexCapsule1.getTimestamp(),2); + Assert.assertNotNull(delegatedResourceAccountIndexCapsule2); + Assert.assertEquals(delegatedResourceAccountIndexCapsule2.getTimestamp(),2); + } + + @Test + public void testUnDelegate() throws Exception { + delegatedResourceAccountIndexStore.delegate("testDelegateFrom".getBytes(), + "testDelegateTo".getBytes(),1L); + delegatedResourceAccountIndexStore.unDelegate("testDelegateFrom".getBytes(), + "testDelegateTo".getBytes()); + DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule1 = + delegatedResourceAccountIndexStore.get(Bytes.concat(FROM_PREFIX, + "testDelegateFrom".getBytes(), "testDelegateTo".getBytes())); + DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule2 = + delegatedResourceAccountIndexStore.get(Bytes.concat(TO_PREFIX, + "testDelegateTo".getBytes(), "testDelegateFrom".getBytes())); + Assert.assertNull(delegatedResourceAccountIndexCapsule1); + Assert.assertNull(delegatedResourceAccountIndexCapsule2); + } + + @Test + public void testUnDelegateV2() { + delegatedResourceAccountIndexStore.delegateV2("testDelegateFrom".getBytes(), + "testDelegateTo".getBytes(),1L); + delegatedResourceAccountIndexStore.unDelegateV2("testDelegateFrom".getBytes(), + "testDelegateTo".getBytes()); + DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule1 = + delegatedResourceAccountIndexStore.get(Bytes.concat(V2_FROM_PREFIX, + "testDelegateFrom".getBytes(), "testDelegateTo".getBytes())); + DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule2 = + delegatedResourceAccountIndexStore.get(Bytes.concat(V2_TO_PREFIX, + "testDelegateTo".getBytes(), "testDelegateFrom".getBytes())); + Assert.assertNull(delegatedResourceAccountIndexCapsule1); + Assert.assertNull(delegatedResourceAccountIndexCapsule2); + } + + @Test + public void testGetIndex() throws Exception { + DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule = + delegatedResourceAccountIndexStore.getIndex("testGetIndex".getBytes()); + Assert.assertNotNull(delegatedResourceAccountIndexCapsule); + Assert.assertNotNull(delegatedResourceAccountIndexCapsule.getFromAccountsList()); + Assert.assertNotNull(delegatedResourceAccountIndexCapsule.getToAccountsList()); + } + + @Test + public void testGetV2Index() { + DelegatedResourceAccountIndexCapsule delegatedResourceAccountIndexCapsule = + delegatedResourceAccountIndexStore.getV2Index("testGetV2Index".getBytes()); + Assert.assertNotNull(delegatedResourceAccountIndexCapsule); + Assert.assertNotNull(delegatedResourceAccountIndexCapsule.getFromAccountsList()); + Assert.assertNotNull(delegatedResourceAccountIndexCapsule.getToAccountsList()); + } +} \ No newline at end of file