Merge pull request #69 from helloscoopa/helloscoopa/make-tx-class-tests-to-self-contain

refactor: make tests of `Transaction` class to self contain with few minor improvements

Author: Savjee

README.md

@@ -63,7 +63,7 @@ const myChain = new Blockchain();
 ```js
 // Transfer 100 coins from my wallet to "toAddress"
 const tx = new Transaction(myKey.getPublic('hex'), 'toAddress', 100);
-tx.signTransaction(myKey);
+tx.sign(myKey);
 
 myChain.addTransaction(tx);
 ```

src/blockchain.js

@@ -36,7 +36,7 @@ class Transaction {
    *
    * @param {string} signingKey
    */
-  signTransaction(signingKey) {
+  sign(signingKey) {
     // You can only send a transaction from the wallet that is linked to your
     // key. So here we check if the fromAddress matches your publicKey
     if (signingKey.getPublic('hex') !== this.fromAddress) {

src/main.js

@@ -19,15 +19,15 @@ savjeeCoin.minePendingTransactions(myWalletAddress);
 
 // Create a transaction & sign it with your key
 const tx1 = new Transaction(myWalletAddress, 'address2', 100);
-tx1.signTransaction(myKey);
+tx1.sign(myKey);
 savjeeCoin.addTransaction(tx1);
 
 // Mine block
 savjeeCoin.minePendingTransactions(myWalletAddress);
 
 // Create second transaction
 const tx2 = new Transaction(myWalletAddress, 'address1', 50);
-tx2.signTransaction(myKey);
+tx2.sign(myKey);
 savjeeCoin.addTransaction(tx2);
 
 // Mine block

tests/blockchain.test.js

@@ -94,7 +94,7 @@ describe('Blockchain class', function() {
       // Create new transaction to self
       const tx = new Transaction(walletAddr, walletAddr, 80);
       tx.timestamp = 1;
-      tx.signTransaction(signingKey);
+      tx.sign(signingKey);
 
       blockchain.addTransaction(tx);
       blockchain.minePendingTransactions('no_addr');

tests/helpers.js

@@ -6,7 +6,7 @@ const signingKey = ec.keyFromPrivate('3d6f54430830d388052865b95c10b4aeb1bbe33c01
 function createSignedTx(amount = 10) {
   const txObject = new Transaction(signingKey.getPublic('hex'), 'wallet2', amount);
   txObject.timestamp = 1;
-  txObject.signTransaction(signingKey);
+  txObject.sign(signingKey);
 
   return txObject;
 }
@@ -23,7 +23,7 @@ function createBlockchainWithTx() {
   blockchain.minePendingTransactions(signingKey.getPublic('hex'));
 
   const validTx = new Transaction(signingKey.getPublic('hex'), 'b2', 10);
-  validTx.signTransaction(signingKey);
+  validTx.sign(signingKey);
 
   blockchain.addTransaction(validTx);
   blockchain.addTransaction(validTx);

tests/transaction.test.js

@@ -1,15 +1,19 @@
 const assert = require('assert');
+
 const { Transaction } = require('../src/blockchain');
 const { createSignedTx, signingKey } = require('./helpers');
 
-let txObject = null;
+describe('Transaction class', function() {
+  let txObject = null;
+  const fromAddress = 'fromAddress';
+  const toAddress = 'toAddress';
+  const amount = 100;
 
-beforeEach(function() {
-  txObject = new Transaction('fromAddress', 'toAddress', 9999);
-});
+  beforeEach(function() {
+    txObject = new Transaction(fromAddress, toAddress, amount);
+  });
 
-describe('Transaction class', function() {
-  describe('Constructor', function() {
+  describe('constructor', function() {
     it('should automatically set the current date', function() {
       const actual = txObject.timestamp;
       const minTime = Date.now() - 1000;
@@ -18,87 +22,79 @@ describe('Transaction class', function() {
       assert(actual > minTime && actual < maxTime, 'Tx does not have a good timestamp');
     });
 
-
     it('should correctly save from, to and amount', function() {
-      txObject = new Transaction('a1', 'b1', 10);
-
-      assert.strict.equal(txObject.fromAddress, 'a1');
-      assert.strict.equal(txObject.toAddress, 'b1');
-      assert.strict.equal(txObject.amount, 10);
+      assert.strict.equal(txObject.fromAddress, fromAddress);
+      assert.strict.equal(txObject.toAddress, toAddress);
+      assert.strict.equal(txObject.amount, amount);
     });
   });
 
-  describe('Calculate hash', function() {
-    it('should correct calculate the SHA256', function() {
-      txObject = new Transaction('a1', 'b1', 10);
+  describe('calculateHash', function() {
+    it('should correctly calculate the SHA256 hash', function() {
       txObject.timestamp = 1;
 
       assert.strict.equal(
         txObject.calculateHash(),
-
-        // Output of SHA256(a1b1101)
-        '21894bb7b0e56aab9eb48d4402d94628a9a179bc277542a5703f417900275153'
+        '4be9c20f87f7baac191aa246a33b5d44af1f96f23598ac06e5f71ee222f40abf'
       );
     });
 
-    it('should change when we tamper with the tx', function() {
-      txObject = new Transaction('a1', 'b1', 10);
-
-      const originalHash = txObject.calculateHash();
-      txObject.amount = 100;
+    it('should output a different hash if data is tampered in the transaction', function() {
+      // Tamper the amount making the hash different
+      txObject.amount = 50;
 
       assert.strict.notEqual(
         txObject.calculateHash(),
-        originalHash
+        txObject.hash
       );
     });
   });
 
-  describe('isValid', function() {
-    it('should throw error without signature', function() {
-      assert.throws(() => { txObject.isValid(); }, Error);
-    });
-
+  describe('sign', function() {
     it('should correctly sign transactions', function() {
       txObject = createSignedTx();
 
       assert.strict.equal(
         txObject.signature,
-        '3044022023fb1d818a0888f7563e1a3ccdd68b28e23070d6c0c1c5' +
-'004721ee1013f1d769022037da026cda35f95ef1ee5ced5b9f7d70' +
-'e102fcf841e6240950c61e8f9b6ef9f8'
+        '3044022023fb1d818a0888f7563e1a3ccdd68b28e23070d6c0c1c5004721ee1013f1d7' +
+        '69022037da026cda35f95ef1ee5ced5b9f7d70e102fcf841e6240950c61e8f9b6ef9f8'
       );
     });
 
-    it('should not sign transactions for other wallets', function() {
-      txObject = new Transaction('not a correct wallet key', 'wallet2', 10);
-      txObject.timestamp = 1;
+    it('should not sign transactions with fromAddresses that does not belogs to the private key', function() {
+      txObject.fromAddress = 'some-other-address';
 
       assert.throws(() => {
-        txObject.signTransaction(signingKey);
+        txObject.sign(signingKey);
       }, Error);
     });
+  });
 
-    it('should detect badly signed transactions', function() {
-      txObject = createSignedTx();
-
-      // Tamper with it & it should be invalid!
-      txObject.amount = 100;
-      assert(!txObject.isValid());
-    });
-
-    it('should return true with correctly signed tx', function() {
-      txObject = createSignedTx();
+  describe('isValid', function() {
+    it('should return true for mining reward transactions', function() {
+      txObject.fromAddress = null;
       assert(txObject.isValid());
     });
 
-    it('should fail when signature is empty string', function() {
+    it('should throw error if signature is invalid', function() {
+      delete txObject.signature;
+      assert.throws(() => { txObject.isValid(); }, Error);
+
       txObject.signature = '';
       assert.throws(() => { txObject.isValid(); }, Error);
     });
 
-    it('should return true for mining rewards', function() {
-      txObject.fromAddress = null;
+    it('should return false for badly signed transactions', function() {
+      txObject = createSignedTx(10);
+
+      // Tamper the amount making the signature invalid
+      txObject.amount = 50;
+
+      assert(!txObject.isValid());
+    });
+
+    it('should return true for correctly signed tx', function() {
+      txObject = createSignedTx(10);
       assert(txObject.isValid());
     });
   });