Integration Tests: balance, tx-history, address-info and transaction routes

.eslintrc

@@ -0,0 +1,48 @@
+{
+  "extends": "airbnb-base",
+  "parser": "@babel/eslint-parser",
+  "rules": {
+    "arrow-parens": ["error", "as-needed"],
+    "import/no-named-as-default": 0,
+    "import/prefer-default-export": 0,
+    "quotes": ["error", "single", { "avoidEscape": true, "allowTemplateLiterals": true }],
+    "comma-dangle": 0,
+    "object-curly-newline": ["error", {"ObjectPattern": { "multiline": true }}],
+    "eqeqeq": [1, "allow-null"],
+    "no-continue": 0,
+    "no-cond-assign": 1,
+    "no-constant-condition": 0,
+    "no-control-regex": 1,
+    "no-debugger": 1,
+    "no-dupe-keys": 1,
+    "no-ex-assign": 1,
+    "no-extra-boolean-cast": 1,
+    "no-func-assign": 1,
+    "no-regex-spaces": 1,
+    "no-unreachable": 1,
+    "no-fallthrough": 1,
+    "no-lone-blocks": 1,
+    "no-delete-var": 1,
+    "no-shadow": 1,
+    "no-shadow-restricted-names": 1,
+    "no-undef": 2,
+    "no-undef-init": 1,
+    "no-use-before-define": 0,
+    "no-unused-vars": [1, {"vars": "all", "args": "none"}],
+    "no-underscore-dangle": 0,
+    "no-restricted-syntax": ["error", "LabeledStatement", "WithStatement"],
+    "no-await-in-loop": "off",
+    "no-plusplus": "off",
+    "guard-for-in": "off"
+  },
+  "overrides": [
+    {
+      "files": [
+        "**/*.test.js"
+      ],
+      "env": {
+        "jest": true
+      }
+    }
+  ]
+}

.github/workflows/integration-test.yml

@@ -0,0 +1,44 @@
+name: integration-test
+on:
+  push:
+    branches:
+      - master
+      - dev
+    tags:
+      - v*
+    pull_request:
+      branches:
+        - dev
+        - master
+jobs:
+  itest:
+    runs-on: ubuntu-20.04
+    timeout-minutes: 20
+
+    strategy:
+      matrix:
+        node-version: [14.x]
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v1
+        with:
+          node-version: ${{ matrix.node-version }}
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Copy config file
+        run: cp ./__tests__/integration/configuration/config.js.template ./src/config.js
+
+      - name: Run the tests
+        run: npm run test_integration
+
+      - name: Upload debug transaction logs
+        if: always()
+        uses: actions/upload-artifact@v2
+        with:
+          name: test-transacion-logs
+          path: tmp

__tests__/integration/address-info.test.js

@@ -0,0 +1,176 @@
+import {
+  getRandomInt,
+  HATHOR_TOKEN_ID,
+  TestUtils,
+  WALLET_CONSTANTS
+} from './utils/test-utils-integration';
+import { WalletHelper } from './utils/wallet-helper';
+
+describe('address-info routes', () => {
+  let wallet1;
+  let wallet2;
+  const address1balance = getRandomInt(200, 100);
+  let customTokenHash;
+
+  beforeAll(async () => {
+    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 wallet2.injectFunds(10);
+      const customToken = await wallet2.createToken({
+        amount: 500,
+        name: 'AddInfo Token',
+        symbol: 'AIT',
+        address: await wallet2.getAddressAt(1),
+        change_address: await wallet2.getAddressAt(0)
+      });
+      customTokenHash = customToken.hash;
+
+      /*
+       * The state here should be:
+       * wallet1[1] with some value between 100 and 200 HTR
+       * wallet2[0] with 5 HTR
+       * wallet2[1] with 500 AIT
+       */
+    } catch (err) {
+      TestUtils.logError(err.stack);
+    }
+  });
+
+  afterAll(async () => {
+    await wallet1.stop();
+    await wallet2.stop();
+  });
+
+  it('should return results for an address (empty)', async done => {
+    const response = await TestUtils.request
+      .get('/wallet/address-info')
+      .query({ address: await wallet1.getAddressAt(0) })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.status).toBe(200);
+
+    const results = response.body;
+    expect(results.success).toBeTruthy();
+    expect(results.token).toBe(HATHOR_TOKEN_ID);
+    expect(results.index).toBe(0);
+    expect(results.total_amount_received).toBe(0);
+    expect(results.total_amount_sent).toBe(0);
+    expect(results.total_amount_available).toBe(0);
+    expect(results.total_amount_locked).toBe(0);
+    done();
+  });
+
+  it('should return results for an address with a single receiving transaction', async done => {
+    const response = await TestUtils.request
+      .get('/wallet/address-info')
+      .query({ address: await wallet1.getAddressAt(1) })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(response.status).toBe(200);
+
+    const results = response.body;
+    expect(results.success).toBeTruthy();
+    expect(results.token).toBe(HATHOR_TOKEN_ID);
+    expect(results.index).toBe(1);
+    expect(results.total_amount_received).toBe(address1balance);
+    expect(results.total_amount_sent).toBe(0);
+    expect(results.total_amount_available).toBe(address1balance);
+    expect(results.total_amount_locked).toBe(0);
+    done();
+  });
+
+  it('should return correct locked balance for an address with miner rewards', async done => {
+    const response = await TestUtils.request
+      .get('/wallet/address-info')
+      .query({ address: WALLET_CONSTANTS.genesis.addresses[1] }) // Miner rewards address
+      .set({ 'x-wallet-id': WALLET_CONSTANTS.genesis.walletId });
+
+    expect(response.status).toBe(200);
+
+    const results = response.body;
+    expect(results.success).toBeTruthy();
+    expect(results.token).toBe(HATHOR_TOKEN_ID);
+    expect(results.index).toBe(2);
+    expect(results.total_amount_received).toBeGreaterThan(0);
+
+    /*
+     * According to the REWARD_SPEND_MIN_BLOCKS variable in the ./configuration/privnet.py file
+     * the miner rewards are locked for exactly one block. Since we have only one miner reward
+     * address, this value should be always 6400 or greater.
+     *
+     * Should another miner reward address be included later, this assertion must be recalculated.
+     */
+    expect(results.total_amount_locked).toBeGreaterThanOrEqual(6400);
+    done();
+  });
+
+  it('should return results for an address with send/receive transactions', async done => {
+    const response = await TestUtils.request
+      .get('/wallet/address-info')
+      .query({ address: await wallet2.getAddressAt(0) })
+      .set({ 'x-wallet-id': wallet2.walletId });
+
+    expect(response.status).toBe(200);
+
+    const results = response.body;
+    expect(results.success).toBeTruthy();
+    expect(results.token).toBe(HATHOR_TOKEN_ID);
+    expect(results.index).toBe(0);
+    expect(results.total_amount_received).toBe(15); // 10 from genesis, 5 from token creation change
+    expect(results.total_amount_sent).toBe(10); // token creation tx
+    expect(results.total_amount_available).toBe(5); // change
+    expect(results.total_amount_locked).toBe(0);
+    done();
+  });
+
+  it('should return results for custom token for an address (empty)', async done => {
+    const response = await TestUtils.request
+      .get('/wallet/address-info')
+      .query({
+        address: await wallet2.getAddressAt(0),
+        token: customTokenHash,
+      })
+      .set({ 'x-wallet-id': wallet2.walletId });
+
+    expect(response.status).toBe(200);
+
+    const results = response.body;
+    expect(results.success).toBeTruthy();
+    expect(results.token).toBe(customTokenHash);
+    expect(results.index).toBe(0);
+    expect(results.total_amount_received).toBe(0);
+    expect(results.total_amount_sent).toBe(0);
+    expect(results.total_amount_available).toBe(0);
+    expect(results.total_amount_locked).toBe(0);
+    done();
+  });
+
+  it('should return results for custom token on an address with a single transaction', async done => {
+    const response = await TestUtils.request
+      .get('/wallet/address-info')
+      .query({
+        address: await wallet2.getAddressAt(1),
+        token: customTokenHash,
+      })
+      .set({ 'x-wallet-id': wallet2.walletId });
+
+    expect(response.status).toBe(200);
+
+    const results = response.body;
+    expect(results.success).toBeTruthy();
+    expect(results.token).toBe(customTokenHash);
+    expect(results.index).toBe(1);
+    expect(results.total_amount_received).toBe(500);
+    expect(results.total_amount_sent).toBe(0);
+    expect(results.total_amount_available).toBe(500);
+    expect(results.total_amount_locked).toBe(0);
+    done();
+  });
+});

__tests__/integration/balance.test.js

@@ -0,0 +1,102 @@
+import { getRandomInt, TestUtils, WALLET_CONSTANTS } from './utils/test-utils-integration';
+import { WalletHelper } from './utils/wallet-helper';
+
+describe('balance routes', () => {
+  /** @type WalletHelper */
+  let wallet1;
+  let wallet2;
+  let wallet3;
+  const wallet2Balance = getRandomInt(200);
+
+  beforeAll(async () => {
+    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 wallet3.injectFunds(100);
+    } catch (err) {
+      TestUtils.logError(err.stack);
+    }
+  });
+
+  afterAll(async () => {
+    await wallet1.stop();
+    await wallet2.stop();
+    await wallet3.stop();
+  });
+
+  it('should return zero for an empty wallet', async done => {
+    const balanceResult = await TestUtils.request
+      .get('/wallet/balance')
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(balanceResult.body.available).toBe(0);
+    expect(balanceResult.body.locked).toBe(0);
+    done();
+  });
+
+  it('should return correct balance for a wallet with one transaction', async done => {
+    const balanceResult = await TestUtils.request
+      .get('/wallet/balance')
+      .set({ 'x-wallet-id': wallet2.walletId });
+
+    expect(balanceResult.body.available).toBe(wallet2Balance);
+    expect(balanceResult.body.locked).toBe(0);
+    done();
+  });
+
+  it('should return some locked balance for the miner wallet', async done => {
+    const balanceResult = await TestUtils.request
+      .get('/wallet/balance')
+      .set({ 'x-wallet-id': WALLET_CONSTANTS.genesis.walletId });
+
+    /*
+     * According to the REWARD_SPEND_MIN_BLOCKS variable in the ./configuration/privnet.py file
+     * the miner rewards are locked for exactly one block. Since we have only one miner reward
+     * address, this value should be always 6400 or greater.
+     *
+     * Should another miner reward address be included later, this assertion must be recalculated.
+     */
+    expect(balanceResult.body.locked).toBeGreaterThanOrEqual(6400);
+    done();
+  });
+
+  it('should return correct balance for a custom token (empty)', async done => {
+    const balanceResult = await TestUtils.request
+      .get('/wallet/balance')
+      .query({ token: 'TST' })
+      .set({ 'x-wallet-id': wallet1.walletId });
+
+    expect(balanceResult.body.available).toBe(0);
+    expect(balanceResult.body.locked).toBe(0);
+    done();
+  });
+
+  it('should return correct balance for a custom token', async done => {
+    const tokenAmount = getRandomInt(200, 100);
+    const newToken = await wallet3.createToken({
+      name: 'Test Token',
+      symbol: 'TST',
+      amount: tokenAmount,
+    });
+    const tokenHash = newToken.hash;
+
+    const balanceResult = await TestUtils.request
+      .get('/wallet/balance')
+      .query({ token: tokenHash })
+      .set({ 'x-wallet-id': wallet3.walletId });
+
+    expect(balanceResult.body.available).toBe(tokenAmount);
+    expect(balanceResult.body.locked).toBe(0);
+    done();
+  });
+});