Integration tests: simple send-tx, send-tx, create-tokens, mint and melt tokens (#152)

* docs: minor changes to jsdocs

* perf: wallets starting in parallel instead of serially

* feat: simple-send-tx tests

* feat: send-tx tests with single token and automatic inputs

* refactor: logging address samples when starting multiple wallets

* test: sending with filter_address query

* test: sending with single input

* test: sending with multiple inputs

* test: sending a custom token

* test: sending custom tokens with inputs and "body.token" property

* test: send-tx with multiple tokens

* refactor: successful transactions changed to use wallet helper

* style: applied standardized formatting

* test: create-token tests

* test: mint-token tests

* test: melt-tokens tests

* refactor: improving docs and naming for clarity

* style: linting

* style: fix wrong linting of expect calls

* docs: minor fixes to comments and jsdocs

* refactor: wallet validation pooling off by default

* perf: transactions no longer pause to wait for websocket response

This operation should be explicit whenever an operation to get balance
is to be done.

* docs: jsdocs, comments and variable renaming

* feat: new helper functions for wallet txHistory and balance

* refactor: improvements to create-token legibility

* test: testing all input possibilities on create-token

* test: testing all input possibilities on mint-tokens

* test: improving assertions and validations on simple-send-tx

* test: improving assertions and validations on melt-tokens

* test: improving assertions and validations on send-tx

* test: multi-token, automatic change address test

* style: eslint

* test: create-token field size validations

* test: new token api tests with a single input and with no inputs

* refactor: renaming variables for clarity

* fix: made tests more strict and skipped failing ones

* fix: removing unnecessary tests and assertions

* test: including assertion for change address on basic create token test

* style: converted static string templates into single tick strings

* perf: wallet starter now working in parallel

* refactor: removed irrelevant afterAll() on setupTests-integration

* style: typo

* refactor: websocket update delay period moved to config file

* feat: timeout protection on multiple wallet initialization.

* chore: added new timeout variable to config files

* docs: added todos on pending assertions

These todos should be reviewed together with the skipped tests on a
future issue

* chore: moved test configurations to separate file

also, they are now editable via environment variables

Author: tuliomir

.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,
@@ -32,6 +31,8 @@ describe('address-info routes', () => {
       });
       customTokenHash = customToken.hash;
 
+      await TestUtils.pauseForWsUpdate();
+
       /*
        * The state here should be:
        * wallet1[1] with some value between 100 and 200 HTR

__tests__/integration/balance.test.js

@@ -12,17 +12,16 @@ 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);
+
+      await TestUtils.pauseForWsUpdate();
     } catch (err) {
       TestUtils.logError(err.stack);
     }
@@ -90,6 +89,8 @@ describe('balance routes', () => {
     });
     const tokenHash = newToken.hash;
 
+    await TestUtils.pauseForWsUpdate();
+
     const balanceResult = await TestUtils.request
       .get('/wallet/balance')
       .query({ token: tokenHash })

__tests__/integration/configuration/config.js.template

@@ -46,11 +46,6 @@ module.exports = {
   },
   */
 
-  // Integration test transaction logging
-  integrationTestLog: {
-    outputFolder: 'tmp/', // Should match .github/workflows/integration-test.yml -> upload-artifact
-  },
-
   // Optional config so you can set the token you want to use in this wallet
   // If this parameter is set you don't need to pass your token when getting balance or sending tokens
   tokenUid: '',

__tests__/integration/configuration/test.config.js

@@ -0,0 +1,18 @@
+/*
+ * This file contains the configurations specific for the integration tests on the Wallet Headless.
+ * Those values are also editable via envrionment variables
+ */
+
+module.exports = {
+  // On CI, should match .github/workflows/integration-test.yml -> upload-artifact
+  logOutputFolder: process.env.TEST_LOG_OUTPUT_FOLDER || 'tmp/',
+
+  // Console level used on winston
+  consoleLevel: process.env.TEST_CONSOLE_LEVEL || 'silly',
+
+  // Defines how long tests should wait before consulting balances after transactions
+  wsUpdateDelay: process.env.TEST_WS_UPDATE_DELAY || 1000,
+
+  // Defines for how long the startMultipleWalletsForTest can run
+  walletStartTimeout: process.env.TEST_WALLET_START_TIMEOUT || 60000,
+};

__tests__/integration/create-token.test.js

@@ -0,0 +1,275 @@
+import { getRandomInt, TestUtils, WALLET_CONSTANTS } from './utils/test-utils-integration';
+import { WalletHelper } from './utils/wallet-helper';
+
+describe('create token', () => {
+  let wallet1;
+  let wallet2;
+
+  const tokenA = {
+    name: 'Token A',
+    symbol: 'TKA',
+    uid: null
+  };
+
+  beforeAll(async () => {
+    wallet1 = new WalletHelper('create-token-1');
+    wallet2 = new WalletHelper('create-token-2');
+
+    await WalletHelper.startMultipleWalletsForTest([wallet1, wallet2]);
+    await wallet1.injectFunds(10, 0);
+    await wallet1.injectFunds(10, 1);
+    await wallet2.injectFunds(10, 0);
+  });
+
+  afterAll(async () => {
+    await wallet1.stop();
+    await wallet2.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();
+  });
+
+  it.skip('should reject a name with more than 30 characters', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/create-token')
+      .send({
+        name: 'Name input with more than 30 characters',
+        symbol: tokenA.symbol,
+        amount: 2000
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.body.success).toBe(false);
+    expect(response.body.error).toContain('maximum size');
+    done();
+  });
+
+  // The result is an error with the message "maximum size", but consumes the funds. Must be fixed.
+  it.skip('should reject a symbol with more than 5 characters', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/create-token')
+      .send({
+        name: tokenA.name,
+        symbol: 'TKABCD',
+        amount: 2000
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.body.success).toBe(false);
+    expect(response.body.error).toContain('maximum size');
+    done();
+  });
+
+  it('should reject an invalid destination address', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/create-token')
+      .send({
+        name: tokenA.name,
+        symbol: tokenA.symbol,
+        amount: 1000,
+        address: 'invalidAddress'
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.status).toBe(200);
+    expect(response.body.success).toBe(false);
+    expect(response.body.error).toContain('base58');
+    done();
+  });
+
+  it('should reject an invalid change address', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/create-token')
+      .send({
+        name: tokenA.name,
+        symbol: tokenA.symbol,
+        amount: 500,
+        address: await wallet1.getAddressAt(0),
+        change_address: 'invalidAddress'
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.status).toBe(200);
+    expect(response.body.success).toBe(false);
+    expect(response.body.error).toContain('Change address');
+    done();
+  });
+
+  // The application is incorrectly allowing external addresses to receive the change
+  it.skip('should reject creating token for change address not in the wallet', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/create-token')
+      .send({
+        name: tokenA.name,
+        symbol: tokenA.symbol,
+        amount: 500,
+        address: await wallet1.getAddressAt(0),
+        change_address: WALLET_CONSTANTS.genesis.addresses[3]
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.status).toBe(200);
+    expect(response.body.success).toBe(false);
+    expect(response.text).toContain('wallet');
+    done();
+  });
+
+  // insufficient funds
+
+  it('should reject for insufficient 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 with only required parameters', 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();
+
+    await TestUtils.pauseForWsUpdate();
+
+    const htrBalance = await wallet1.getBalance();
+    const tkaBalance = await wallet1.getBalance(response.body.hash);
+    expect(htrBalance.available).toBe(19); // The initial 20 minus 1
+    expect(tkaBalance.available).toBe(100); // The newly minted TKA tokens
+    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: 'Token B',
+        symbol: 'TKB',
+        amount: amountTokens,
+        address: await wallet1.getAddressAt(9)
+      })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    const transaction = response.body;
+    expect(transaction.success).toBe(true);
+
+    await TestUtils.pauseForWsUpdate();
+
+    const addr9 = await wallet1.getAddressInfo(9, transaction.hash);
+    expect(addr9.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: 'Token C',
+        symbol: 'TKC',
+        amount: 100,
+        change_address: await wallet2.getAddressAt(5)
+      })
+      .set({ 'x-wallet-id': wallet2.walletId });
+
+    const transaction = response.body;
+    expect(transaction.success).toBe(true);
+
+    // The only output with token_data equals zero is the one containing the HTR change
+    const htrOutputIndex = transaction.outputs.findIndex(o => o.token_data === 0);
+    const htrChange = transaction.outputs[htrOutputIndex].value;
+
+    await TestUtils.pauseForWsUpdate();
+
+    const addr5 = await wallet2.getAddressInfo(5);
+    expect(addr5.total_amount_received).toBe(htrChange);
+    done();
+  });
+
+  it('should create a token with all available inputs', async done => {
+    const response = await TestUtils.request
+      .post('/wallet/create-token')
+      .send({
+        name: 'Token D',
+        symbol: 'TKD',
+        amount: 200,
+        address: await wallet2.getAddressAt(4),
+        change_address: await wallet2.getAddressAt(4)
+      })
+      .set({ 'x-wallet-id': wallet2.walletId });
+
+    const transaction = response.body;
+    expect(transaction.success).toBe(true);
+
+    // The only output with token_data equals zero is the one containing the HTR change
+    const htrOutputIndex = transaction.outputs.findIndex(o => o.token_data === 0);
+    const htrChange = transaction.outputs[htrOutputIndex].value;
+
+    await TestUtils.pauseForWsUpdate();
+
+    const addr4 = await wallet2.getAddressInfo(4);
+    expect(addr4.total_amount_received).toBe(htrChange);
+    const addr4C = await wallet2.getAddressInfo(4, transaction.hash);
+    expect(addr4C.total_amount_available).toBe(200);
+    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",