Integration tests: simple send-tx, send-tx, create-tokens, mint and melt tokens

.gitignore

@@ -5,5 +5,6 @@ config.js
 node_modules/
 
 coverage
+coverage-integration
 
 .DS_Store

__tests__/integration/address-info.test.js

@@ -16,12 +16,11 @@ describe('address-info routes', () => {
     try {
       // A random HTR value for the first wallet
       wallet1 = new WalletHelper('addinfo-1');
-      await wallet1.start();
-      await wallet1.injectFunds(address1balance, 1);
-
       // A fixed custom token amount for the second wallet
       wallet2 = new WalletHelper('addinfo-2');
-      await wallet2.start();
+
+      await WalletHelper.startMultipleWalletsForTest([wallet1, wallet2]);
+      await wallet1.injectFunds(address1balance, 1);
       await wallet2.injectFunds(10);
       const customToken = await wallet2.createToken({
         amount: 500,

__tests__/integration/balance.test.js

@@ -12,16 +12,13 @@ describe('balance routes', () => {
     try {
       // First wallet, no balance
       wallet1 = new WalletHelper('balance1');
-      await wallet1.start();
-
       // Second wallet, random balance
       wallet2 = new WalletHelper('balance2');
-      await wallet2.start();
-      await wallet2.injectFunds(wallet2Balance);
-
       // Third wallet, balance to be used for custom tokens
       wallet3 = new WalletHelper('custom3');
-      await wallet3.start();
+
+      await WalletHelper.startMultipleWalletsForTest([wallet1, wallet2, wallet3]);
+      await wallet2.injectFunds(wallet2Balance);
       await wallet3.injectFunds(100);
     } catch (err) {
       TestUtils.logError(err.stack);

__tests__/integration/create-token.test.js

@@ -0,0 +1,172 @@
+import { getRandomInt, TestUtils } from './utils/test-utils-integration';
+import { WalletHelper } from './utils/wallet-helper';
+
+describe('create token', () => {
+  let wallet1;
+  let wallet2;
+
+  const fundTx1 = {
+    hash: null,
+    index: null
+  };
+  const fundTx2 = {
+    hash: null,
+    index: null
+  };
+
+  const tokenA = {
+    name: 'Token A',
+    symbol: 'TKA',
+    uid: null
+  };
+  const tokenB = {
+    name: 'Token B',
+    symbol: 'TKB',
+    uid: null
+  };
+
+  beforeAll(async () => {
+    wallet1 = new WalletHelper('create-token-1');
+    wallet2 = new WalletHelper('create-token-2');
+
+    await WalletHelper.startMultipleWalletsForTest([wallet1, wallet2]);
+    const fundTxObj1 = await wallet1.injectFunds(10, 0, { doNotWait: true });
+    fundTx1.hash = fundTxObj1.hash;
+    fundTx1.index = TestUtils.getOutputIndexFromTx(fundTxObj1, 10);
+
+    const fundTxObj2 = await wallet1.injectFunds(10, 1, { doNotWait: true });
+    fundTx2.hash = fundTxObj2.hash;
+    fundTx2.index = TestUtils.getOutputIndexFromTx(fundTxObj2, 10);
+
+    await wallet2.injectFunds(10, 0, { doNotWait: true });
+    await TestUtils.delay(1000);
+  });
+
+  afterAll(async () => {
+    await wallet1.stop();
+  });
+
+  // Testing failures first, that do not cause side-effects on the blockchain
+
+  it('should reject missing name parameter', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/create-token')
+      .send({
+        symbol: tokenA.symbol,
+        amount: 1000
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.status).toBe(400);
+    expect(response.body.success).toBe(false);
+    done();
+  });
+
+  it('should reject missing symbol parameter', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/create-token')
+      .send({
+        name: tokenA.name,
+        amount: 1000
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.status).toBe(400);
+    expect(response.body.success).toBe(false);
+    done();
+  });
+
+  // Insuficcient funds
+
+  it('should reject for insuficcient funds', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/create-token')
+      .send({
+        name: tokenA.name,
+        symbol: tokenA.symbol,
+        amount: 3000
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.status).toBe(200);
+    expect(response.body.success).toBe(false);
+    expect(response.body.hash).toBeUndefined();
+    done();
+  });
+
+  it('should not create a token with the reserved HTR symbol', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/create-token')
+      .send({
+        name: 'Hathor',
+        symbol: 'HTR',
+        amount: 100
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.status).toBe(200);
+    expect(response.body.success).toBe(false);
+    expect(response.body.hash).toBeUndefined();
+    expect(response.body.error).toContain('Invalid token name');
+    done();
+  });
+
+  it('should create a token successfully', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/create-token')
+      .send({
+        name: tokenA.name,
+        symbol: tokenA.symbol,
+        amount: 100
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.body.success).toBe(true);
+    expect(response.body.hash).toBeDefined();
+    done();
+  });
+
+  it('should send the created tokens to the correct address', async done => {
+    const amountTokens = getRandomInt(100, 200);
+    const response = await TestUtils.request
+      .post('/wallet/create-token')
+      .send({
+        name: tokenB.name,
+        symbol: tokenB.symbol,
+        amount: amountTokens,
+        address: await wallet1.getAddressAt(9)
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    const transaction = response.body;
+    expect(transaction.success).toBe(true);
+
+    const addr8 = await wallet1.getAddressInfo(9, transaction.hash);
+    expect(addr8.total_amount_received).toBe(amountTokens);
+    done();
+  });
+
+  it('should send the change to the correct address', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/create-token')
+      .send({
+        name: tokenB.name,
+        symbol: tokenB.symbol,
+        amount: 100,
+        change_address: await wallet2.getAddressAt(5)
+      })
+      .set({ 'x-wallet-id': wallet2.walletId });
+
+    const transaction = response.body;
+    expect(transaction.success).toBe(true);
+    const customTokenOutputIndex = TestUtils.getOutputIndexFromTx(transaction, 100);
+
+    // If the custom token output is 0, the HTR will be on the output index 1. And vice-versa.
+    const htrOutputIndex = customTokenOutputIndex === 1 ? 0 : 1;
+    const htrChange = transaction.outputs[htrOutputIndex].value;
+
+    const addr8 = await wallet1.getAddressInfo(5);
+    expect(addr8.total_amount_received).toBe(htrChange);
+    done();
+  });
+});

__tests__/integration/docker-compose.yml

@@ -33,7 +33,7 @@ services:
     depends_on:
       - fullnode
     ports:
-      - "8034:8034" # Not mandatory to keep these ports open, but helpful for developer machine debugging
+      - "8034:8034" # Not mandatory to keep this port open, but helpful for developer machine debugging
       - "8035:8035"
     command: [
       "http://fullnode:8080",

__tests__/integration/melt-tokens.test.js

@@ -0,0 +1,122 @@
+import { TestUtils } from './utils/test-utils-integration';
+import { WalletHelper } from './utils/wallet-helper';
+
+describe('melt tokens', () => {
+  let wallet1;
+  const tokenA = {
+    name: 'Token A',
+    symbol: 'TKA',
+    uid: null
+  };
+
+  beforeAll(async () => {
+    wallet1 = new WalletHelper('melt-token-1');
+
+    // Starting the wallets
+    await WalletHelper.startMultipleWalletsForTest([wallet1]);
+
+    // Creating a token for the tests
+    await wallet1.injectFunds(10, 0, { doNotWait: true });
+    const tkAtx = await wallet1.createToken({
+      name: tokenA.name,
+      symbol: tokenA.symbol,
+      amount: 800,
+      address: await wallet1.getAddressAt(0),
+      change_address: await wallet1.getAddressAt(0)
+    });
+    tokenA.uid = tkAtx.hash;
+  });
+
+  afterAll(async () => {
+    await wallet1.stop();
+  });
+
+  // Testing failures first, that do not cause side-effects on the blockchain
+
+  it('should not melt an invalid token', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/melt-tokens')
+      .send({
+        token: 'invalidToken',
+        amount: 100
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.status).toBe(200);
+    expect(response.body.success).toBe(false);
+
+    // Even though the result is correct, the error thrown is not related. Should be fixed later.
+    // expect(response.body.error).toContain('invalid');
+    done();
+  });
+
+  it('should not melt with an invalid amount', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/melt-tokens')
+      .send({
+        token: tokenA.uid,
+        amount: 'invalidVamount'
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.status).toBe(400);
+    expect(response.body.success).toBe(false);
+    expect(response.text).toContain('invalid');
+    done();
+  });
+
+  // Insufficient funds
+
+  it('should not melt with insuficcient tokens', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/melt-tokens')
+      .send({
+        token: tokenA.uid,
+        address: await wallet1.getAddressAt(1),
+        amount: 1000
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.status).toBe(200);
+    expect(response.body.success).toBe(false);
+    expect(response.body.error).toContain('enough inputs to melt');
+    done();
+  });
+
+  // Success
+
+  it('should melt with correct parameters', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/melt-tokens')
+      .send({
+        token: tokenA.uid,
+        address: await wallet1.getAddressAt(1),
+        amount: 300
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.body.success).toBe(true);
+    done();
+  });
+
+  it('should melt all the tokens', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/melt-tokens')
+      .send({
+        token: tokenA.uid,
+        address: await wallet1.getAddressAt(1),
+        amount: 500
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.body.success).toBe(true);
+
+    const balanceResult = await TestUtils.request
+      .get('/wallet/balance')
+      .query({ token: tokenA.uid })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(balanceResult.body.available).toBe(0);
+    done();
+  });
+});