From fc3e951e8e8f3ecd85213818f58fe23a398f9d12 Mon Sep 17 00:00:00 2001 From: catbref Date: Wed, 13 Jun 2018 16:48:28 +0100 Subject: [PATCH] Renamed and converted unit tests **COMPILES OK BUT UNTESTED** Let the debugging begin! --- src/{test => }/migrate.java | 39 +++--- src/qora/block/Block.java | 9 ++ src/test/BlockTests.java | 121 ++++++++++++++++++ src/test/BlockchainTests.java | 15 +++ src/test/Common.java | 27 ++++ src/test/{crypto.java => CryptoTests.java} | 2 +- .../{exceptions.java => ExceptionTests.java} | 2 +- src/test/LoadTests.java | 89 +++++++++++++ src/test/NavigationTests.java | 43 +++++++ src/test/RepositoryTests.java | 44 +++++++ src/test/SaveTests.java | 33 +++++ .../{signatures.java => SignatureTests.java} | 28 ++-- src/test/TransactionTests.java | 86 +++++++++++++ src/test/blockchain.java | 16 --- src/test/blocks.java | 89 ------------- src/test/common.java | 27 ---- src/test/connections.java | 54 -------- src/test/load.java | 69 ---------- src/test/navigation.java | 36 ------ src/test/save.java | 29 ----- src/test/transactions.java | 70 ---------- src/test/updates.java | 16 --- 22 files changed, 509 insertions(+), 435 deletions(-) rename src/{test => }/migrate.java (96%) create mode 100644 src/test/BlockTests.java create mode 100644 src/test/BlockchainTests.java create mode 100644 src/test/Common.java rename src/test/{crypto.java => CryptoTests.java} (97%) rename src/test/{exceptions.java => ExceptionTests.java} (98%) create mode 100644 src/test/LoadTests.java create mode 100644 src/test/NavigationTests.java create mode 100644 src/test/RepositoryTests.java create mode 100644 src/test/SaveTests.java rename src/test/{signatures.java => SignatureTests.java} (61%) create mode 100644 src/test/TransactionTests.java delete mode 100644 src/test/blockchain.java delete mode 100644 src/test/blocks.java delete mode 100644 src/test/common.java delete mode 100644 src/test/connections.java delete mode 100644 src/test/load.java delete mode 100644 src/test/navigation.java delete mode 100644 src/test/save.java delete mode 100644 src/test/transactions.java delete mode 100644 src/test/updates.java diff --git a/src/test/migrate.java b/src/migrate.java similarity index 96% rename from src/test/migrate.java rename to src/migrate.java index 51cedaa1..c8a68646 100644 --- a/src/test/migrate.java +++ b/src/migrate.java @@ -1,5 +1,3 @@ -package test; - import static org.junit.Assert.*; import java.io.BufferedReader; @@ -24,24 +22,25 @@ import org.json.simple.JSONArray; import org.json.simple.JSONObject; import org.json.simple.JSONValue; import org.json.simple.parser.ParseException; -import org.junit.Test; import com.google.common.hash.HashCode; import com.google.common.io.CharStreams; -import database.DB; -import qora.block.BlockChain; -import qora.transaction.TransactionHandler; +import qora.transaction.Transaction; +import repository.BlockRepository; +import repository.DataException; +import repository.Repository; +import repository.RepositoryManager; import utils.Base58; -public class migrate extends common { +public class migrate { private static final String GENESIS_ADDRESS = "QfGMeDQQUQePMpAmfLBJzgqyrM35RWxHGD"; private static final byte[] GENESIS_PUBLICKEY = new byte[] { 1, 1, 1, 1, 1, 1, 1, 1 }; private static Map publicKeyByAddress = new HashMap(); - public Object fetchBlockJSON(int height) throws IOException { + public static Object fetchBlockJSON(int height) throws IOException { InputStream is; try { @@ -60,7 +59,7 @@ public class migrate extends common { } } - public byte[] addressToPublicKey(String address) throws IOException { + public static byte[] addressToPublicKey(String address) throws IOException { byte[] cachedPublicKey = publicKeyByAddress.get(address); if (cachedPublicKey != null) return cachedPublicKey; @@ -78,7 +77,7 @@ public class migrate extends common { } } - public String formatWithPlaceholders(String... columns) { + public static String formatWithPlaceholders(String... columns) { String[] placeholders = new String[columns.length]; Arrays.setAll(placeholders, (int i) -> "?"); @@ -91,14 +90,18 @@ public class migrate extends common { return output.toString(); } - @Test - public void testMigration() throws SQLException, IOException { + public static void main(String args[]) throws SQLException, DataException, IOException { // Genesis public key publicKeyByAddress.put(GENESIS_ADDRESS, GENESIS_PUBLICKEY); // Some other public keys for addresses that have never created a transaction publicKeyByAddress.put("QcDLhirHkSbR4TLYeShLzHw61B8UGTFusk", Base58.decode("HP58uWRBae654ze6ysmdyGv3qaDrr9BEk6cHv4WuiF7d")); - Connection c = DB.getConnection(); + // TODO convert to repository + Connection c = null; + + test.Common.setRepository(); + Repository repository = RepositoryManager.getRepository(); + BlockRepository blockRepository = repository.getBlockRepository(); PreparedStatement blocksPStmt = c .prepareStatement("INSERT INTO Blocks " + formatWithPlaceholders("signature", "version", "reference", "transaction_count", "total_fees", @@ -150,7 +153,7 @@ public class migrate extends common { PreparedStatement blockTxPStmt = c .prepareStatement("INSERT INTO BlockTransactions " + formatWithPlaceholders("block_signature", "sequence", "transaction_signature")); - int height = BlockChain.getHeight() + 1; + int height = blockRepository.getBlockchainHeight() + 1; byte[] milestone_block = null; System.out.println("Starting migration from block height " + height); @@ -164,8 +167,6 @@ public class migrate extends common { JSONArray transactions = (JSONArray) json.get("transactions"); - DB.startTransaction(); - // Blocks: // signature, version, reference, transaction_count, total_fees, transactions_signature, height, generation, generating_balance, generator, // generator_signature @@ -561,7 +562,7 @@ public class migrate extends common { } messagePStmt.setBinaryStream(1, new ByteArrayInputStream(txSignature)); - messagePStmt.setInt(2, TransactionHandler.getVersionByTimestamp(transactionTimestamp)); + messagePStmt.setInt(2, Transaction.getVersionByTimestamp(transactionTimestamp)); messagePStmt.setBinaryStream(3, new ByteArrayInputStream(addressToPublicKey((String) transaction.get("creator")))); messagePStmt.setString(4, (String) transaction.get("recipient")); messagePStmt.setBoolean(5, isText); @@ -590,7 +591,7 @@ public class migrate extends common { blockTxPStmt.execute(); blockTxPStmt.clearParameters(); - DB.commit(); + repository.saveChanges(); } // new milestone block every 500 blocks? @@ -600,7 +601,7 @@ public class migrate extends common { ++height; } - System.out.println("Migration finished with new blockchain height " + BlockChain.getHeight()); + System.out.println("Migration finished with new blockchain height " + blockRepository.getBlockchainHeight()); } } diff --git a/src/qora/block/Block.java b/src/qora/block/Block.java index 8a2caff5..8d69384c 100644 --- a/src/qora/block/Block.java +++ b/src/qora/block/Block.java @@ -82,6 +82,15 @@ public class Block { this.generator = new PublicKeyAccount(repository, blockData.getGeneratorPublicKey()); } + // For creating a new block + public Block(Repository repository, int version, byte[] reference, long timestamp, BigDecimal generatingBalance, PrivateKeyAccount generator, + byte[] atBytes, BigDecimal atFees) { + this.repository = repository; + this.generator = generator; + this.blockData = new BlockData(version, reference, 0, BigDecimal.ZERO.setScale(8), null, 0, timestamp, generatingBalance, generator.getPublicKey(), + null, atBytes, atFees); + } + // Getters/setters public BlockData getBlockData() { diff --git a/src/test/BlockTests.java b/src/test/BlockTests.java new file mode 100644 index 00000000..5b9cdc17 --- /dev/null +++ b/src/test/BlockTests.java @@ -0,0 +1,121 @@ +package test; + +import static org.junit.Assert.*; + +import java.math.BigDecimal; +import java.util.List; + +import org.junit.Test; + +import data.block.BlockData; +import data.transaction.TransactionData; +import qora.block.Block; +import qora.block.GenesisBlock; +import qora.transaction.Transaction; +import repository.DataException; +import repository.Repository; +import repository.RepositoryManager; +import transform.TransformationException; +import transform.block.BlockTransformer; + +public class BlockTests extends Common { + + @Test + public void testGenesisBlockTransactions() throws DataException { + Repository repository = RepositoryManager.getRepository(); + GenesisBlock block = new GenesisBlock(repository); + + assertNotNull(block); + assertTrue(block.isSignatureValid()); + // only true if blockchain is empty + // assertTrue(block.isValid(connection)); + + List transactions = block.getTransactions(); + assertNotNull(transactions); + + for (Transaction transaction : transactions) { + assertNotNull(transaction); + + TransactionData transactionData = transaction.getTransactionData(); + + assertEquals(Transaction.TransactionType.GENESIS, transactionData.getType()); + assertTrue(transactionData.getFee().compareTo(BigDecimal.ZERO) == 0); + assertNull(transactionData.getReference()); + assertTrue(transaction.isSignatureValid()); + assertEquals(Transaction.ValidationResult.OK, transaction.isValid()); + } + + // Attempt to load first transaction directly from database + TransactionData transactionData = repository.getTransactionRepository().fromSignature(transactions.get(0).getTransactionData().getSignature()); + assertNotNull(transactionData); + + assertEquals(Transaction.TransactionType.GENESIS, transactionData.getType()); + assertTrue(transactionData.getFee().compareTo(BigDecimal.ZERO) == 0); + assertNull(transactionData.getReference()); + + Transaction transaction = Transaction.fromData(repository, transactionData); + assertNotNull(transaction); + + assertTrue(transaction.isSignatureValid()); + assertEquals(Transaction.ValidationResult.OK, transaction.isValid()); + } + + @Test + public void testBlockPaymentTransactions() throws DataException { + Repository repository = RepositoryManager.getRepository(); + + // Block 949 has lots of varied transactions + // Blocks 390 & 754 have only payment transactions + BlockData blockData = repository.getBlockRepository().fromHeight(754); + assertNotNull("Block 754 is required for this test", blockData); + + Block block = new Block(repository, blockData); + assertTrue(block.isSignatureValid()); + + List transactions = block.getTransactions(); + assertNotNull(transactions); + + for (Transaction transaction : transactions) { + assertNotNull(transaction); + + TransactionData transactionData = transaction.getTransactionData(); + + assertEquals(Transaction.TransactionType.PAYMENT, transactionData.getType()); + assertFalse(transactionData.getFee().compareTo(BigDecimal.ZERO) == 0); + assertNotNull(transactionData.getReference()); + + assertTrue(transaction.isSignatureValid()); + } + + // Attempt to load first transaction directly from database + TransactionData transactionData = repository.getTransactionRepository().fromSignature(transactions.get(0).getTransactionData().getSignature()); + assertNotNull(transactionData); + + assertEquals(Transaction.TransactionType.GENESIS, transactionData.getType()); + assertTrue(transactionData.getFee().compareTo(BigDecimal.ZERO) == 0); + assertNull(transactionData.getReference()); + + Transaction transaction = Transaction.fromData(repository, transactionData); + assertNotNull(transaction); + + assertTrue(transaction.isSignatureValid()); + } + + @Test + public void testBlockSerialization() throws DataException, TransformationException { + Repository repository = RepositoryManager.getRepository(); + + // Block 949 has lots of varied transactions + // Blocks 390 & 754 have only payment transactions + BlockData blockData = repository.getBlockRepository().fromHeight(754); + assertNotNull("Block 754 is required for this test", blockData); + + Block block = new Block(repository, blockData); + assertTrue(block.isSignatureValid()); + + byte[] bytes = BlockTransformer.toBytes(block); + + assertEquals(BlockTransformer.getDataLength(block), bytes.length); + } + +} diff --git a/src/test/BlockchainTests.java b/src/test/BlockchainTests.java new file mode 100644 index 00000000..264f8773 --- /dev/null +++ b/src/test/BlockchainTests.java @@ -0,0 +1,15 @@ +package test; + +import org.junit.Test; + +import qora.block.BlockChain; +import repository.DataException; + +public class BlockchainTests extends Common { + + @Test + public void testValidateOrRebuild() throws DataException { + BlockChain.validate(); + } + +} diff --git a/src/test/Common.java b/src/test/Common.java new file mode 100644 index 00000000..e0fe9cec --- /dev/null +++ b/src/test/Common.java @@ -0,0 +1,27 @@ +package test; + +import org.junit.AfterClass; +import org.junit.BeforeClass; + +import repository.DataException; +import repository.RepositoryFactory; +import repository.RepositoryManager; +import repository.hsqldb.HSQLDBRepositoryFactory; + +public class Common { + + public static final String connectionUrl = "jdbc:hsqldb:file:db/test;create=true;close_result=true;sql.strict_exec=true;sql.enforce_names=true;sql.syntax_mys=true"; + + @BeforeClass + public static void setRepository() throws DataException { + RepositoryFactory repositoryFactory = new HSQLDBRepositoryFactory(connectionUrl); + + RepositoryManager.setRepositoryFactory(repositoryFactory); + } + + @AfterClass + public static void closeRepository() throws DataException { + // Currently a no-op? + } + +} diff --git a/src/test/crypto.java b/src/test/CryptoTests.java similarity index 97% rename from src/test/crypto.java rename to src/test/CryptoTests.java index 33746dd0..dfe7299b 100644 --- a/src/test/crypto.java +++ b/src/test/CryptoTests.java @@ -8,7 +8,7 @@ import com.google.common.hash.HashCode; import qora.crypto.Crypto; -public class crypto { +public class CryptoTests { @Test public void testCryptoDigest() { diff --git a/src/test/exceptions.java b/src/test/ExceptionTests.java similarity index 98% rename from src/test/exceptions.java rename to src/test/ExceptionTests.java index 8a8ac0e6..37100d53 100644 --- a/src/test/exceptions.java +++ b/src/test/ExceptionTests.java @@ -5,7 +5,7 @@ import static org.junit.Assert.*; import org.junit.Test; import qora.block.Block; -public class exceptions { +public class ExceptionTests { /** * Proof of concept for block processing throwing transaction-related SQLException rather than savepoint-rollback-related SQLException. diff --git a/src/test/LoadTests.java b/src/test/LoadTests.java new file mode 100644 index 00000000..5fb0d0e3 --- /dev/null +++ b/src/test/LoadTests.java @@ -0,0 +1,89 @@ +package test; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import data.transaction.PaymentTransactionData; +import data.transaction.TransactionData; +import qora.account.PublicKeyAccount; +import qora.transaction.Transaction.TransactionType; +import repository.DataException; +import repository.Repository; +import repository.RepositoryManager; +import repository.TransactionRepository; +import utils.Base58; + +public class LoadTests extends Common { + + @Test + public void testLoadPaymentTransaction() throws DataException { + Repository repository = RepositoryManager.getRepository(); + TransactionRepository transactionRepository = repository.getTransactionRepository(); + + assertTrue("Migrate from old database to at least block 49778 before running this test", + repository.getBlockRepository().getBlockchainHeight() >= 49778); + + String signature58 = "1211ZPwG3hk5evWzXCZi9hMDRpwumWmkENjwWkeTCik9xA5uoYnxzF7rwR5hmHH3kG2RXo7ToCAaRc7dvnynByJt"; + byte[] signature = Base58.decode(signature58); + + TransactionData transactionData = transactionRepository.fromSignature(signature); + assertNotNull("Transaction data not loaded from repository", transactionData); + assertEquals("Transaction data not PAYMENT type", TransactionType.PAYMENT, transactionData.getType().value); + assertEquals(PublicKeyAccount.getAddress(transactionData.getCreatorPublicKey()), "QXwu8924WdgPoRmtiWQBUMF6eedmp1Hu2E"); + + PaymentTransactionData paymentTransactionData = (PaymentTransactionData) transactionData; + + assertNotNull(paymentTransactionData); + assertEquals(PublicKeyAccount.getAddress(paymentTransactionData.getSenderPublicKey()), "QXwu8924WdgPoRmtiWQBUMF6eedmp1Hu2E"); + assertEquals(paymentTransactionData.getRecipient(), "QZsv8vbJ6QfrBNba4LMp5UtHhAzhrxvVUU"); + assertEquals(paymentTransactionData.getTimestamp(), 1416209264000L); + assertEquals(Base58.encode(paymentTransactionData.getReference()), + "31dC6kHHBeG5vYb8LMaZDjLEmhc9kQB2VUApVd8xWncSRiXu7yMejdprjYFMP2rUnzZxWd4KJhkq6LsV7rQvU1kY"); + } + + @Test + public void testLoadFactory() throws DataException { + Repository repository = RepositoryManager.getRepository(); + TransactionRepository transactionRepository = repository.getTransactionRepository(); + + assertTrue("Migrate from old database to at least block 49778 before running this test", + repository.getBlockRepository().getBlockchainHeight() >= 49778); + + String signature58 = "1211ZPwG3hk5evWzXCZi9hMDRpwumWmkENjwWkeTCik9xA5uoYnxzF7rwR5hmHH3kG2RXo7ToCAaRc7dvnynByJt"; + byte[] signature = Base58.decode(signature58); + + while (true) { + TransactionData transactionData = transactionRepository.fromSignature(signature); + if (transactionData == null) + break; + + PaymentTransactionData paymentTransactionData = (PaymentTransactionData) transactionData; + System.out.println(PublicKeyAccount.getAddress(paymentTransactionData.getSenderPublicKey()) + " sent " + paymentTransactionData.getAmount() + + " QORA to " + paymentTransactionData.getRecipient()); + + signature = paymentTransactionData.getReference(); + } + } + + @Test + public void testLoadNonexistentTransaction() throws DataException { + Repository repository = RepositoryManager.getRepository(); + TransactionRepository transactionRepository = repository.getTransactionRepository(); + + String signature58 = "1111222233334444"; + byte[] signature = Base58.decode(signature58); + + TransactionData transactionData = transactionRepository.fromSignature(signature); + + if (transactionData != null) { + PaymentTransactionData paymentTransactionData = (PaymentTransactionData) transactionData; + + System.out.println(PublicKeyAccount.getAddress(paymentTransactionData.getSenderPublicKey()) + " sent " + paymentTransactionData.getAmount() + + " QORA to " + paymentTransactionData.getRecipient()); + + fail(); + } + } + +} diff --git a/src/test/NavigationTests.java b/src/test/NavigationTests.java new file mode 100644 index 00000000..36336934 --- /dev/null +++ b/src/test/NavigationTests.java @@ -0,0 +1,43 @@ +package test; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import data.block.BlockData; +import data.transaction.TransactionData; +import qora.transaction.Transaction.TransactionType; +import repository.DataException; +import repository.Repository; +import repository.RepositoryManager; +import repository.TransactionRepository; +import utils.Base58; + +public class NavigationTests extends Common { + + @Test + public void testNavigateFromTransactionToBlock() throws DataException { + Repository repository = RepositoryManager.getRepository(); + TransactionRepository transactionRepository = repository.getTransactionRepository(); + + assertTrue("Migrate from old database to at least block 49778 before running this test", + repository.getBlockRepository().getBlockchainHeight() >= 49778); + + String signature58 = "1211ZPwG3hk5evWzXCZi9hMDRpwumWmkENjwWkeTCik9xA5uoYnxzF7rwR5hmHH3kG2RXo7ToCAaRc7dvnynByJt"; + byte[] signature = Base58.decode(signature58); + + System.out.println("Navigating to Block from transaction " + signature58); + + TransactionData transactionData = transactionRepository.fromSignature(signature); + assertNotNull("Transaction data not loaded from repository", transactionData); + assertEquals("Transaction data not PAYMENT type", TransactionType.PAYMENT, transactionData.getType().value); + + BlockData blockData = transactionRepository.toBlock(transactionData); + assertNotNull("Block 49778 not loaded from database", blockData); + + System.out.println("Block " + blockData.getHeight() + ", signature: " + Base58.encode(blockData.getSignature())); + + assertEquals(49778, blockData.getHeight()); + } + +} diff --git a/src/test/RepositoryTests.java b/src/test/RepositoryTests.java new file mode 100644 index 00000000..d4ac6cd7 --- /dev/null +++ b/src/test/RepositoryTests.java @@ -0,0 +1,44 @@ +package test; + +import static org.junit.Assert.*; + +import org.junit.Test; + +import repository.DataException; +import repository.Repository; +import repository.RepositoryManager; + +public class RepositoryTests extends Common { + + @Test + public void testGetRepository() throws DataException { + Repository repository = RepositoryManager.getRepository(); + assertNotNull(repository); + } + + @Test + public void testMultipleInstances() throws DataException { + int n_instances = 5; + Repository[] repositories = new Repository[n_instances]; + + for (int i = 0; i < n_instances; ++i) { + repositories[i] = RepositoryManager.getRepository(); + assertNotNull(repositories[i]); + } + } + + @Test + public void testAccessAfterCommit() throws DataException { + Repository repository = RepositoryManager.getRepository(); + assertNotNull(repository); + + repository.saveChanges(); + + try { + repository.discardChanges(); + fail(); + } catch (DataException e) { + } + } + +} diff --git a/src/test/SaveTests.java b/src/test/SaveTests.java new file mode 100644 index 00000000..053e54e5 --- /dev/null +++ b/src/test/SaveTests.java @@ -0,0 +1,33 @@ +package test; + +import java.math.BigDecimal; +import java.time.Instant; + +import org.junit.Test; + +import data.transaction.PaymentTransactionData; +import qora.account.PublicKeyAccount; +import repository.DataException; +import repository.Repository; +import repository.RepositoryManager; +import utils.Base58; + +public class SaveTests extends Common { + + @Test + public void testSavePaymentTransaction() throws DataException { + Repository repository = RepositoryManager.getRepository(); + + String reference58 = "rrrr"; + byte[] reference = Base58.decode(reference58); + String signature58 = "ssss"; + byte[] signature = Base58.decode(signature58); + PublicKeyAccount sender = new PublicKeyAccount(repository, "Qsender".getBytes()); + + PaymentTransactionData paymentTransactionData = new PaymentTransactionData(sender.getPublicKey(), "Qrecipient", BigDecimal.valueOf(12345L), + BigDecimal.ONE, Instant.now().getEpochSecond(), reference, signature); + + repository.getTransactionRepository().save(paymentTransactionData); + } + +} diff --git a/src/test/signatures.java b/src/test/SignatureTests.java similarity index 61% rename from src/test/signatures.java rename to src/test/SignatureTests.java index 42437795..79267a96 100644 --- a/src/test/signatures.java +++ b/src/test/SignatureTests.java @@ -3,42 +3,54 @@ package test; import static org.junit.Assert.*; import java.math.BigDecimal; -import java.sql.SQLException; import org.junit.Test; +import data.block.BlockData; import qora.account.PrivateKeyAccount; import qora.block.Block; import qora.block.GenesisBlock; +import repository.DataException; +import repository.Repository; +import repository.RepositoryManager; import utils.Base58; import utils.NTP; -public class signatures extends common { +public class SignatureTests extends Common { @Test - public void testGenesisBlockSignature() throws SQLException { + public void testGenesisBlockSignature() throws DataException { String expected58 = "6pHMBFif7jXFG654joT8GPaymau1fMtaxacRyqSrnAwQMQDvqRuLpHpfFyqX4gWVvj4pF1mwQhFgqWAvjVvPJUjmBZQvL751dM9cEcQBTaUcxtNLuWZCVUAtbnWN9f7FsLppHhkPbxwpoodL3UJYRGt3EZrG17mhv1RJbmq8j6rr7Mk"; - GenesisBlock block = GenesisBlock.getInstance(); + Repository repository = RepositoryManager.getRepository(); + GenesisBlock block = new GenesisBlock(repository); + BlockData blockData = block.getBlockData(); - System.out.println("Generator: " + block.getGenerator().getAddress() + ", generator signature: " + Base58.encode(block.getGeneratorSignature())); + System.out.println("Generator: " + block.getGenerator().getAddress() + ", generator signature: " + Base58.encode(blockData.getGeneratorSignature())); assertEquals(expected58, Base58.encode(block.getSignature())); } @Test - public void testBlockSignature() throws SQLException { + public void testBlockSignature() throws DataException { int version = 3; + byte[] reference = Base58.decode( "BSfgEr6r1rXGGJCv8criR5NcBWfpHdJnm9x5unPwxvojEKCESv1wH1zJm7yvCeC48wshymYtARbHdUojbqWCCWW7h2UTc8g5oEx59C9M41dM7H48My8gVkcEZdxR1of3VgpE5UcowFp3kFC12hVcD9hUttJ2i2nZWMwprbFtUGyVv1U"); + long timestamp = NTP.getTime() - 5000; + BigDecimal generatingBalance = BigDecimal.valueOf(10_000_000L).setScale(8); - PrivateKeyAccount generator = new PrivateKeyAccount( + + Repository repository = RepositoryManager.getRepository(); + PrivateKeyAccount generator = new PrivateKeyAccount(repository, new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 }); + byte[] atBytes = null; + BigDecimal atFees = null; - Block block = new Block(version, reference, timestamp, generatingBalance, generator, atBytes, atFees); + Block block = new Block(repository, version, reference, timestamp, generatingBalance, generator, atBytes, atFees); block.calcGeneratorSignature(); block.calcTransactionsSignature(); diff --git a/src/test/TransactionTests.java b/src/test/TransactionTests.java new file mode 100644 index 00000000..cfbaec7c --- /dev/null +++ b/src/test/TransactionTests.java @@ -0,0 +1,86 @@ +package test; + +import static org.junit.Assert.*; + +import java.sql.SQLException; +import java.util.Arrays; +import java.util.List; + +import org.junit.Test; + +import data.block.BlockData; +import data.transaction.GenesisTransactionData; +import data.transaction.TransactionData; +import qora.block.Block; +import qora.block.GenesisBlock; +import qora.transaction.GenesisTransaction; +import qora.transaction.Transaction; +import repository.DataException; +import repository.Repository; +import repository.RepositoryManager; +import transform.TransformationException; +import transform.transaction.TransactionTransformer; + +public class TransactionTests extends Common { + + @Test + public void testGenesisSerialization() throws TransformationException, DataException { + Repository repository = RepositoryManager.getRepository(); + GenesisBlock block = new GenesisBlock(repository); + + GenesisTransaction transaction = (GenesisTransaction) block.getTransactions().get(1); + assertNotNull(transaction); + + GenesisTransactionData genesisTransactionData = (GenesisTransactionData) transaction.getTransactionData(); + + System.out.println(genesisTransactionData.getTimestamp() + ": " + genesisTransactionData.getRecipient() + " received " + + genesisTransactionData.getAmount().toPlainString()); + + byte[] bytes = TransactionTransformer.toBytes(genesisTransactionData); + + GenesisTransactionData parsedTransactionData = (GenesisTransactionData) TransactionTransformer.fromBytes(bytes); + + System.out.println(parsedTransactionData.getTimestamp() + ": " + parsedTransactionData.getRecipient() + " received " + + parsedTransactionData.getAmount().toPlainString()); + + assertTrue(Arrays.equals(genesisTransactionData.getSignature(), parsedTransactionData.getSignature())); + } + + private void testGenericSerialization(TransactionData transactionData) throws TransformationException { + assertNotNull(transactionData); + + byte[] bytes = TransactionTransformer.toBytes(transactionData); + + TransactionData parsedTransactionData = TransactionTransformer.fromBytes(bytes); + + assertTrue(Arrays.equals(transactionData.getSignature(), parsedTransactionData.getSignature())); + + assertEquals(TransactionTransformer.getDataLength(transactionData), bytes.length); + } + + @Test + public void testPaymentSerialization() throws TransformationException, DataException { + Repository repository = RepositoryManager.getRepository(); + + // Block 949 has lots of varied transactions + // Blocks 390 & 754 have only payment transactions + BlockData blockData = repository.getBlockRepository().fromHeight(754); + assertNotNull("Block 754 is required for this test", blockData); + + Block block = new Block(repository, blockData); + assertTrue(block.isSignatureValid()); + + List transactions = block.getTransactions(); + assertNotNull(transactions); + + for (Transaction transaction : transactions) + testGenericSerialization(transaction.getTransactionData()); + } + + @Test + public void testMessageSerialization() throws SQLException, TransformationException { + // Message transactions went live block 99000 + // Some transactions to be found in block 99001/2/5/6 + } + +} \ No newline at end of file diff --git a/src/test/blockchain.java b/src/test/blockchain.java deleted file mode 100644 index ef54f5ac..00000000 --- a/src/test/blockchain.java +++ /dev/null @@ -1,16 +0,0 @@ -package test; - -import java.sql.SQLException; - -import org.junit.Test; - -import qora.block.BlockChain; - -public class blockchain extends common { - - @Test - public void testRebuild() throws SQLException { - BlockChain.validate(); - } - -} diff --git a/src/test/blocks.java b/src/test/blocks.java deleted file mode 100644 index eaf9e7a9..00000000 --- a/src/test/blocks.java +++ /dev/null @@ -1,89 +0,0 @@ -package test; - -import static org.junit.Assert.*; - -import java.math.BigDecimal; -import java.sql.SQLException; -import java.util.List; - -import org.junit.Test; - -import qora.block.Block; -import qora.block.GenesisBlock; -import qora.transaction.TransactionHandler; -import qora.transaction.TransactionHandler; - -public class blocks extends common { - - @Test - public void testGenesisBlockTransactions() throws SQLException { - GenesisBlock block = GenesisBlock.getInstance(); - assertNotNull(block); - assertTrue(block.isSignatureValid()); - // only true if blockchain is empty - // assertTrue(block.isValid(connection)); - - List transactions = block.getTransactions(); - assertNotNull(transactions); - - for (TransactionHandler transaction : transactions) { - assertNotNull(transaction); - assertEquals(Transaction.TransactionHandler.GENESIS, transaction.getType()); - assertTrue(transaction.getFee().compareTo(BigDecimal.ZERO) == 0); - assertNull(transaction.getReference()); - assertTrue(transaction.isSignatureValid()); - assertEquals(TransactionHandler.ValidationResult.OK, transaction.isValid()); - } - - // Attempt to load first transaction directly from database - TransactionHandler transaction = TransactionFactory.fromSignature(transactions.get(0).getSignature()); - assertNotNull(transaction); - assertEquals(Transaction.TransactionHandler.GENESIS, transaction.getType()); - assertTrue(transaction.getFee().compareTo(BigDecimal.ZERO) == 0); - assertNull(transaction.getReference()); - assertTrue(transaction.isSignatureValid()); - assertEquals(TransactionHandler.ValidationResult.OK, transaction.isValid()); - } - - @Test - public void testBlockPaymentTransactions() throws SQLException { - // Block 949 has lots of varied transactions - // Blocks 390 & 754 have only payment transactions - Block block = Block.fromHeight(754); - assertNotNull("Block 754 is required for this test", block); - assertTrue(block.isSignatureValid()); - - List transactions = block.getTransactions(); - assertNotNull(transactions); - - for (TransactionHandler transaction : transactions) { - assertNotNull(transaction); - assertEquals(Transaction.TransactionHandler.PAYMENT, transaction.getType()); - assertFalse(transaction.getFee().compareTo(BigDecimal.ZERO) == 0); - assertNotNull(transaction.getReference()); - assertTrue(transaction.isSignatureValid()); - } - - // Attempt to load first transaction directly from database - TransactionHandler transaction = TransactionFactory.fromSignature(transactions.get(0).getSignature()); - assertNotNull(transaction); - assertEquals(Transaction.TransactionHandler.PAYMENT, transaction.getType()); - assertFalse(transaction.getFee().compareTo(BigDecimal.ZERO) == 0); - assertNotNull(transaction.getReference()); - assertTrue(transaction.isSignatureValid()); - } - - @Test - public void testBlockSerialization() throws SQLException { - // Block 949 has lots of varied transactions - // Blocks 390 & 754 have only payment transactions - Block block = Block.fromHeight(754); - assertNotNull("Block 754 is required for this test", block); - assertTrue(block.isSignatureValid()); - - byte[] bytes = block.toBytes(); - - assertEquals(block.getDataLength(), bytes.length); - } - -} diff --git a/src/test/common.java b/src/test/common.java deleted file mode 100644 index 282a669f..00000000 --- a/src/test/common.java +++ /dev/null @@ -1,27 +0,0 @@ -package test; - -import java.sql.SQLException; - -import org.junit.AfterClass; -import org.junit.BeforeClass; - -import database.DB; -import database.DatabaseUpdates; - -public class common { - - @BeforeClass - public static void setConnection() throws SQLException { - DB.setUrl("jdbc:hsqldb:file:db/test;create=true;close_result=true;sql.strict_exec=true;sql.enforce_names=true;sql.syntax_mys=true"); - DB.open(); - - // Create/update database schema - DatabaseUpdates.updateDatabase(); - } - - @AfterClass - public static void closeDatabase() throws SQLException { - DB.shutdown(); - } - -} diff --git a/src/test/connections.java b/src/test/connections.java deleted file mode 100644 index e5d067a1..00000000 --- a/src/test/connections.java +++ /dev/null @@ -1,54 +0,0 @@ -package test; - -import static org.junit.Assert.*; - -import java.sql.Connection; -import java.sql.SQLException; - -import org.junit.Test; - -import database.DB; - -public class connections extends common { - - @Test - public void testConnection() { - Connection connection = DB.getConnection(); - assertNotNull(connection); - } - - @Test - public void testSimultaneousConnections() { - // First connection is the thread-local one - Connection connection = DB.getConnection(); - assertNotNull(connection); - - int n_connections = 5; - Connection[] connections = new Connection[n_connections]; - - for (int i = 0; i < n_connections; ++i) { - connections[i] = DB.getConnection(); - assertEquals(connection, connections[i]); - } - } - - @Test - public void testConnectionAfterShutdown() { - try { - DB.shutdown(); - } catch (SQLException e) { - e.printStackTrace(); - fail(); - } - - try { - DB.open(); - Connection connection = DB.getConnection(); - assertNotNull(connection); - } catch (SQLException e) { - e.printStackTrace(); - fail(); - } - } - -} diff --git a/src/test/load.java b/src/test/load.java deleted file mode 100644 index aed9c156..00000000 --- a/src/test/load.java +++ /dev/null @@ -1,69 +0,0 @@ -package test; - -import static org.junit.Assert.*; - -import java.sql.SQLException; - -import org.junit.Test; - -import qora.block.BlockChain; -import qora.transaction.PaymentTransaction; -import qora.transaction.TransactionHandler; -import qora.transaction.TransactionHandler; -import utils.Base58; - -public class load extends common { - - @Test - public void testLoadPaymentTransaction() throws SQLException { - assertTrue("Migrate old database to at least block 49778 before running this test", BlockChain.getHeight() >= 49778); - - String signature58 = "1211ZPwG3hk5evWzXCZi9hMDRpwumWmkENjwWkeTCik9xA5uoYnxzF7rwR5hmHH3kG2RXo7ToCAaRc7dvnynByJt"; - byte[] signature = Base58.decode(signature58); - - PaymentTransaction paymentTransaction = PaymentTransaction.fromSignature(signature); - - assertNotNull(paymentTransaction); - assertEquals(paymentTransaction.getSender().getAddress(), "QXwu8924WdgPoRmtiWQBUMF6eedmp1Hu2E"); - assertEquals(paymentTransaction.getCreator().getAddress(), "QXwu8924WdgPoRmtiWQBUMF6eedmp1Hu2E"); - assertEquals(paymentTransaction.getRecipient().getAddress(), "QZsv8vbJ6QfrBNba4LMp5UtHhAzhrxvVUU"); - assertEquals(paymentTransaction.getTimestamp(), 1416209264000L); - assertEquals(Base58.encode(paymentTransaction.getReference()), - "31dC6kHHBeG5vYb8LMaZDjLEmhc9kQB2VUApVd8xWncSRiXu7yMejdprjYFMP2rUnzZxWd4KJhkq6LsV7rQvU1kY"); - } - - @Test - public void testLoadFactory() throws SQLException { - assertTrue("Migrate old database to at least block 49778 before running this test", BlockChain.getHeight() >= 49778); - - String signature58 = "1211ZPwG3hk5evWzXCZi9hMDRpwumWmkENjwWkeTCik9xA5uoYnxzF7rwR5hmHH3kG2RXo7ToCAaRc7dvnynByJt"; - byte[] signature = Base58.decode(signature58); - - while (true) { - TransactionHandler transaction = TransactionFactory.fromSignature(signature); - if (transaction == null) - break; - - PaymentTransaction payment = (PaymentTransaction) transaction; - System.out - .println(payment.getSender().getAddress() + " sent " + payment.getAmount().toString() + " QORA to " + payment.getRecipient().getAddress()); - - signature = payment.getReference(); - } - } - - @Test - public void testLoadNonexistentTransaction() throws SQLException { - String signature58 = "1111222233334444"; - byte[] signature = Base58.decode(signature58); - - PaymentTransaction payment = PaymentTransaction.fromSignature(signature); - - if (payment != null) { - System.out - .println(payment.getSender().getAddress() + " sent " + payment.getAmount().toString() + " QORA to " + payment.getRecipient().getAddress()); - fail(); - } - } - -} diff --git a/src/test/navigation.java b/src/test/navigation.java deleted file mode 100644 index aeeac9cf..00000000 --- a/src/test/navigation.java +++ /dev/null @@ -1,36 +0,0 @@ -package test; - -import static org.junit.Assert.*; - -import java.sql.SQLException; - -import org.junit.Test; - -import qora.block.Block; -import qora.block.BlockChain; -import qora.transaction.PaymentTransaction; -import utils.Base58; - -public class navigation extends common { - - @Test - public void testNavigateFromTransactionToBlock() throws SQLException { - assertTrue("Migrate old database to at least block 49778 before running this test", BlockChain.getHeight() >= 49778); - - String signature58 = "1211ZPwG3hk5evWzXCZi9hMDRpwumWmkENjwWkeTCik9xA5uoYnxzF7rwR5hmHH3kG2RXo7ToCAaRc7dvnynByJt"; - byte[] signature = Base58.decode(signature58); - - System.out.println("Navigating to Block from transaction " + signature58); - - PaymentTransaction paymentTransaction = PaymentTransaction.fromSignature(signature); - assertNotNull("Payment transaction not loaded from database", paymentTransaction); - - Block block = paymentTransaction.getBlock(); - assertNotNull("Block 49778 not loaded from database", block); - - System.out.println("Block " + block.getHeight() + ", signature: " + Base58.encode(block.getSignature())); - - assertEquals(49778, block.getHeight()); - } - -} diff --git a/src/test/save.java b/src/test/save.java deleted file mode 100644 index f488bb3e..00000000 --- a/src/test/save.java +++ /dev/null @@ -1,29 +0,0 @@ -package test; - -import java.math.BigDecimal; -import java.sql.SQLException; -import java.time.Instant; - -import org.junit.Test; - -import qora.account.PublicKeyAccount; -import qora.transaction.PaymentTransaction; -import utils.Base58; - -public class save extends common { - - @Test - public void testSavePaymentTransaction() throws SQLException { - String reference58 = "rrrr"; - byte[] reference = Base58.decode(reference58); - String signature58 = "ssss"; - byte[] signature = Base58.decode(signature58); - PublicKeyAccount sender = new PublicKeyAccount("Qsender".getBytes()); - - PaymentTransaction paymentTransaction = new PaymentTransaction(sender, "Qrecipient", BigDecimal.valueOf(12345L), BigDecimal.ONE, - Instant.now().getEpochSecond(), reference, signature); - - paymentTransaction.save(); - } - -} diff --git a/src/test/transactions.java b/src/test/transactions.java deleted file mode 100644 index f6281655..00000000 --- a/src/test/transactions.java +++ /dev/null @@ -1,70 +0,0 @@ -package test; - -import static org.junit.Assert.*; - -import java.sql.SQLException; -import java.util.Arrays; -import java.util.List; - -import org.junit.Test; - -import qora.block.Block; -import qora.block.GenesisBlock; -import qora.transaction.GenesisTransaction; -import qora.transaction.TransactionHandler; -import transform.TransformationException; - -public class transactions extends common { - - @Test - public void testGenesisSerialization() throws SQLException, TransformationException { - GenesisBlock block = GenesisBlock.getInstance(); - - GenesisTransaction transaction = (GenesisTransaction) block.getTransactions().get(1); - assertNotNull(transaction); - System.out - .println(transaction.getTimestamp() + ": " + transaction.getRecipient().getAddress() + " received " + transaction.getAmount().toPlainString()); - - byte[] bytes = transaction.toBytes(); - - GenesisTransaction parsedTransaction = (GenesisTransaction) TransactionHandler.parse(bytes); - System.out.println(parsedTransaction.getTimestamp() + ": " + parsedTransaction.getRecipient().getAddress() + " received " - + parsedTransaction.getAmount().toPlainString()); - - assertTrue(Arrays.equals(transaction.getSignature(), parsedTransaction.getSignature())); - } - - public void testGenericSerialization(TransactionHandler transaction) throws SQLException, TransformationException { - assertNotNull(transaction); - - byte[] bytes = transaction.toBytes(); - - TransactionHandler parsedTransaction = TransactionHandler.parse(bytes); - - assertTrue(Arrays.equals(transaction.getSignature(), parsedTransaction.getSignature())); - - assertEquals(transaction.getDataLength(), bytes.length); - } - - @Test - public void testPaymentSerialization() throws SQLException, TransformationException { - // Block 949 has lots of varied transactions - // Blocks 390 & 754 have only payment transactions - Block block = Block.fromHeight(754); - assertNotNull("Block 754 is required for this test", block); - assertTrue(block.isSignatureValid()); - - List transactions = block.getTransactions(); - assertNotNull(transactions); - - for (TransactionHandler transaction : transactions) - testGenericSerialization(transaction); - } - - @Test - public void testMessageSerialization() throws SQLException, TransformationException { - // Message transactions went live block 99000 - // Some transactions to be found in block 99001/2/5/6 - } - -} \ No newline at end of file diff --git a/src/test/updates.java b/src/test/updates.java deleted file mode 100644 index 8160e59b..00000000 --- a/src/test/updates.java +++ /dev/null @@ -1,16 +0,0 @@ -package test; - -import java.sql.SQLException; - -import org.junit.Test; - -import database.DatabaseUpdates; - -public class updates extends common { - - @Test - public void testUpdates() throws SQLException { - DatabaseUpdates.updateDatabase(); - } - -}