Add CLI tests and setup CI (#53)

Part of #52

- Add tests for the CLI following demo steps present in the README
- Setup CI to run the CLI tests

Reviewed-on: #53
Co-authored-by: Prathamesh Musale <prathamesh.musale0@gmail.com>
Co-committed-by: Prathamesh Musale <prathamesh.musale0@gmail.com>

.gitea/workflows/test.yml

@@ -12,10 +12,29 @@ env:
   DOCKER_HOST: unix:///var/run/dind.sock
 
 jobs:
-  sdk_tests:
+  cli_tests:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [18.x]
     steps:
       - uses: actions/checkout@v3
+      - name: Download yarn
+        run: |
+          curl -fsSL -o /usr/local/bin/yarn https://github.com/yarnpkg/yarn/releases/download/v1.22.21/yarn-1.22.21.js
+          chmod +x /usr/local/bin/yarn
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v3
+        with:
+          node-version: ${{ matrix.node-version }}
+      - name: Set registry
+        run: npm config set @cerc-io:registry https://git.vdb.to/api/packages/cerc-io/npm/
+
+      - name: Install dependencies and build
+        run: yarn && yarn build
+      - name: Install registry-cli
+        run: yarn global add file:$PWD
+
       - name: Checkout laconicd
         uses: actions/checkout@v3
         with:
@@ -23,23 +42,17 @@ jobs:
           repository: cerc-io/laconicd
           fetch-depth: 0
           ref: main
-      - name: Environment
-        run: ls -tlh && env
-      - name: Start dockerd
-        run: |
-          dockerd -H $DOCKER_HOST --userland-proxy=false &
-          sleep 5
-      - name: build registry-cli container
-        run: docker build -t cerc/laconic-registry-cli:local-test --build-arg CERC_NPM_URL=https://git.vdb.to/api/packages/cerc-io/npm/ --build-arg CERC_NPM_AUTH_TOKEN="${{ secrets.CICD_PUBLISH_TOKEN }}" .
-      - name: build containers scripts
-        working-directory: laconicd/tests/sdk_tests
+
+      - name: Build laconicd container
+        working-directory: ./laconicd/tests/sdk_tests
         run: ./build-laconicd-container.sh
-      - name: start laconicd container
-        working-directory: laconicd/tests/sdk_tests
+      - name: Start laconicd container
+        env:
+          TEST_AUCTION_ENABLED: true
         run: docker compose up laconicd -d
 
-      - name: Run registry-cli demo commands in registry-cli container
-        run : ls -tla
-      - name: stop containers
-        working-directory: laconicd/tests/sdk_tests
+      - name: Run registry-cli tests
+        run: ./test/run-tests.sh
+
+      - name: Stop containers
         run: docker compose down

docker-compose.yml

@@ -1,28 +1,25 @@
 services:
   laconicd:
     restart: unless-stopped
-    image: cerc-io/laconicd:local-test
+    image: cerc/laconicd:local
     command: ["sh", "/docker-entrypoint-scripts.d/create-fixturenet.sh"]
+    environment:
+      - TEST_AUCTION_ENABLED
+      - TEST_REGISTRY_EXPIRY
+      - LOGLEVEL
     volumes:
-      - laconicd/init.sh:/docker-entrypoint-scripts.d/create-fixturenet.sh
+      - ./laconicd/init.sh:/docker-entrypoint-scripts.d/create-fixturenet.sh
     healthcheck:
       test: ["CMD", "curl", "-v", "http://127.0.0.1:6060"]
       interval: 1s
       timeout: 5s
       retries: 30
     ports:
-      - "6060"
-      - "26657"
-      - "26656"
-      - "9473"
-      - "8545"
-      - "8546"
-      - "9090"
-      - "9091"
-      - "1317"
+      - "9473:9473"
+      - "1317:1317"
 
   cli-test-runner:
-    image: cerc/laconic-registry-cli:local-test
+    image: cerc/laconic-registry-cli:local
     depends_on:
       laconicd:
         condition: service_healthy

jest.config.js

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  setupFiles: ["dotenv/config"]
+};

package.json

@@ -7,21 +7,26 @@
   "license": "UNLICENSED",
   "devDependencies": {
     "@types/fs-extra": "^9.0.13",
+    "@types/jest": "^27.4.1",
     "@types/js-yaml": "^4.0.5",
     "@types/lodash": "^4.14.182",
     "@types/node": "^17.0.25",
     "@types/yargs": "^17.0.10",
+    "jest": "29.0.0",
+    "ts-jest": "^29.0.2",
+    "dotenv": "^16.3.2",
     "typescript": "^4.6.3"
   },
   "dependencies": {
-    "fs-extra": "^10.1.0",
     "@cerc-io/laconic-sdk": "^0.1.14",
+    "fs-extra": "^10.1.0",
     "js-yaml": "^3.14.1",
     "lodash": "^4.17.21",
     "lodash-clean": "^2.2.3",
     "yargs": "^17.4.1"
   },
   "scripts": {
+    "test": "jest --runInBand --verbose test/cli.test.ts",
     "lint": "eslint .",
     "clean": "rm -rf ./dist",
     "build": "tsc"

test/cli.test.ts

@@ -0,0 +1,529 @@
+import fs from 'fs';
+import assert from 'assert';
+import { spawnSync } from 'child_process';
+
+import {
+  CHAIN_ID,
+  TOKEN_TYPE,
+  AUCTION_COMMIT_DURATION,
+  AUCTION_REVEAL_DURATION,
+  delay,
+  checkResultAndRetrieveOutput,
+  createBond,
+  getBondObj,
+  getAccountObj,
+  getRecordObj,
+  getAuthorityObj,
+  getAuctionObj,
+  getBidObj
+} from './helpers';
+
+describe('Test laconic CLI commands', () => {
+  test('laconic', async () => {
+    const result = spawnSync('laconic');
+    expect(result.status).toBe(1);
+
+    const output = result.stdout.toString().trim();
+    const errorOutput = result.stderr.toString().trim();
+
+    // Expect error with usage string
+    expect(output).toBe('');
+    expect(errorOutput).toContain('laconic <command>');
+  });
+
+  test('laconic cns', async () => {
+    const result = spawnSync('laconic', ['cns']);
+    expect(result.status).toBe(1);
+
+    const output = result.stdout.toString().trim();
+    const errorOutput = result.stderr.toString().trim();
+
+    // Expect error with usage string
+    expect(output).toBe('');
+    expect(errorOutput).toContain('laconic cns');
+    expect(errorOutput).toContain('CNS tools');
+    expect(errorOutput).toContain('Commands:');
+  });
+
+  // TODO: Break up tests into separate files
+  // TODO: Add tests for CNS commands with all available flags
+
+  describe('laconic CNS commands', () => {
+    const testAccount = process.env.TEST_ACCOUNT;
+    assert(testAccount, 'TEST_ACCOUNT not set in env');
+    const testAccount2 = 'ethm1vc62ysqu504at932jjq8pwrqgjt67rx6ggn5yu';
+    const initialAccountBalance = Number('100000000000000000000000000');
+
+    const testAuthorityName = 'laconic';
+    const testRecordFilePath = 'test/data/watcher-record.yml';
+    let testAuctionId: string, testRecordId: string, testRecordBondId: string;
+
+    test('laconic cns status', async () => {
+      const result = spawnSync('laconic', ['cns', 'status']);
+      const outputObj = checkResultAndRetrieveOutput(result);
+
+      // Expect output object to have CNS status props
+      expect(outputObj).toHaveProperty('version');
+      expect(outputObj).toHaveProperty('node');
+      expect(outputObj).toHaveProperty('node.network', CHAIN_ID);
+      expect(outputObj).toHaveProperty('sync');
+      expect(Number(outputObj.sync.latest_block_height)).toBeGreaterThan(0);
+      expect(outputObj).toHaveProperty('validator');
+      expect(outputObj).toHaveProperty('validators');
+      expect(outputObj).toHaveProperty('num_peers');
+      expect(outputObj).toHaveProperty('peers');
+      expect(outputObj).toHaveProperty('disk_usage');
+    });
+
+    describe('Bond operations', () => {
+      const bondOwner = testAccount;
+      let bondBalance = 1000000000;
+      let bondId: string;
+
+      test('laconic cns bond create --type <type> --quantity <quantity> --gas <gas> --fees <fees>', async () => {
+        const result = spawnSync('laconic', ['cns', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', bondBalance.toString(), '--gas', '200000', '--fees', `200000${TOKEN_TYPE}`]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expect output object to have resultant bond id
+        expect(outputObj.bondId).toBeDefined();
+
+        bondId = outputObj.bondId;
+      });
+
+      test('laconic cns bond list', async () => {
+        const result = spawnSync('laconic', ['cns', 'bond', 'list']);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected bond
+        const expectedBond = getBondObj({ id: bondId, owner: bondOwner, balance: bondBalance });
+
+        expect(outputObj.length).toEqual(1);
+        expect(outputObj[0]).toEqual(expectedBond);
+      });
+
+      test('laconic cns bond list --owner <owner_address>', async () => {
+        const result = spawnSync('laconic', ['cns', 'bond', 'list', '--owner', bondOwner]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected bond
+        const expectedBond = getBondObj({ id: bondId, owner: bondOwner, balance: bondBalance });
+
+        expect(outputObj.length).toEqual(1);
+        expect(outputObj[0]).toEqual(expectedBond);
+      });
+
+      test('laconic cns bond get --id <bond_id>', async () => {
+        const result = spawnSync('laconic', ['cns', 'bond', 'get', '--id', bondId]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected bond
+        const expectedBond = getBondObj({ id: bondId, owner: bondOwner, balance: bondBalance });
+
+        expect(outputObj.length).toEqual(1);
+        expect(outputObj[0]).toEqual(expectedBond);
+      });
+
+      test('laconic cns bond refill --id <bond_id> --type <type> --quantity <quantity>', async () => {
+        const bondRefillAmount = 1000;
+        bondBalance += bondRefillAmount;
+
+        const result = spawnSync('laconic', ['cns', 'bond', 'refill', '--id', bondId, '--type', TOKEN_TYPE, '--quantity', bondRefillAmount.toString()]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected output
+        expect(outputObj).toEqual({ success: true });
+
+        // Check updated bond
+        const bondResult = spawnSync('laconic', ['cns', 'bond', 'get', '--id', bondId]);
+        const bondOutputObj = checkResultAndRetrieveOutput(bondResult);
+
+        // Expected bond
+        const expectedBond = getBondObj({ id: bondId, owner: bondOwner, balance: bondBalance });
+
+        expect(bondOutputObj.length).toEqual(1);
+        expect(bondOutputObj[0]).toEqual(expectedBond);
+      });
+
+      test('laconic cns bond withdraw --id <bond_id> --type <type> --quantity <quantity>', async () => {
+        const bondWithdrawAmount = 500;
+        bondBalance -= bondWithdrawAmount;
+
+        const result = spawnSync('laconic', ['cns', 'bond', 'withdraw', '--id', bondId, '--type', TOKEN_TYPE, '--quantity', bondWithdrawAmount.toString()]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected output
+        expect(outputObj).toEqual({ success: true });
+
+        // Check updated bond
+        const bondResult = spawnSync('laconic', ['cns', 'bond', 'get', '--id', bondId]);
+        const bondOutputObj = checkResultAndRetrieveOutput(bondResult);
+
+        // Expected bond
+        const expectedBond = getBondObj({ id: bondId, owner: bondOwner, balance: bondBalance });
+
+        // Expect balance to be deducted
+        expect(bondOutputObj.length).toEqual(1);
+        expect(bondOutputObj[0]).toEqual(expectedBond);
+      });
+
+      test('laconic cns bond cancel --id <bond_id>', async () => {
+        const result = spawnSync('laconic', ['cns', 'bond', 'cancel', '--id', bondId]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected output
+        expect(outputObj).toEqual({ success: true });
+
+        // Check updated bond
+        const bondResult = spawnSync('laconic', ['cns', 'bond', 'get', '--id', bondId]);
+        const bondOutputObj = checkResultAndRetrieveOutput(bondResult);
+
+        // Expect empty object
+        expect(bondOutputObj.length).toEqual(1);
+        expect(bondOutputObj[0]).toEqual({ id: '', owner: '', balance: [] });
+      });
+    });
+
+    describe('Account and tokens operations', () => {
+      let balanceBeforeSend: number;
+
+      test('laconic cns account get --address <account_address>', async () => {
+        const result = spawnSync('laconic', ['cns', 'account', 'get', '--address', testAccount]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected account
+        const expectedAccount = getAccountObj({ address: testAccount })
+
+        expect(outputObj.length).toEqual(1);
+        expect(outputObj[0]).toMatchObject(expectedAccount);
+        expect(outputObj[0].number).toBeDefined();
+        expect(outputObj[0].sequence).toBeDefined();
+
+        balanceBeforeSend = Number(outputObj[0].balance[0].quantity);
+        expect(balanceBeforeSend).toBeGreaterThan(0);
+        expect(balanceBeforeSend).toBeLessThan(initialAccountBalance);
+      });
+
+      test('laconic cns tokens send --address <account_address> --type <token_type> --quantity <quantity>', async () => {
+        const sendAmount = 1000000000;
+        const balanceAfterSend = balanceBeforeSend - sendAmount;
+
+        const result = spawnSync('laconic', ['cns', 'tokens', 'send', '--address', testAccount2, '--type', TOKEN_TYPE, '--quantity', sendAmount.toString()]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected acconts
+        const expectedAccounts = [
+          getAccountObj({ address: testAccount, balance: balanceAfterSend }),
+          getAccountObj({ address: testAccount2, balance: sendAmount }),
+        ];
+
+        expect(outputObj.length).toEqual(2);
+        expect(outputObj).toMatchObject(expectedAccounts);
+      });
+    });
+
+    describe('Record operations', () => {
+      const gas = 250000;
+      const bondBalance = 1000000000;
+
+      test('laconic cns record publish --filename <record_file> --bond-id <bond_id> --gas <gas>', async () => {
+        // Create a new bond to be associated with the record
+        ({ bondId: testRecordBondId } = createBond(bondBalance));
+
+        const result = spawnSync('laconic', ['cns', 'record', 'publish', '--filename', testRecordFilePath, '--bond-id', testRecordBondId, '--gas', gas.toString()]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expect output object to resultant bond id
+        expect(outputObj.id).toBeDefined();
+
+        testRecordId = outputObj.id;
+      });
+
+      test('laconic cns record list', async () => {
+        const result = spawnSync('laconic', ['cns', 'record', 'list']);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected record
+        const expectedRecord = getRecordObj(testRecordFilePath, { bondId: testRecordBondId, recordId: testRecordId, names: null });
+
+        expect(outputObj.length).toEqual(1);
+        expect(outputObj[0]).toMatchObject(expectedRecord);
+        expect(outputObj[0].createTime).toBeDefined();
+        expect(outputObj[0].expiryTime).toBeDefined();
+        expect(outputObj[0].owners).toBeDefined();
+        expect(outputObj[0].owners.length).toEqual(1);
+      });
+
+      test('laconic cns record get --id <record_id>', async () => {
+        const result = spawnSync('laconic', ['cns', 'record', 'get', '--id', testRecordId]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected record
+        const expectedRecord = getRecordObj(testRecordFilePath, { bondId: testRecordBondId, recordId: testRecordId, names: null });
+
+        expect(outputObj.length).toEqual(1);
+        expect(outputObj[0]).toMatchObject(expectedRecord);
+      });
+
+      describe('Bond records operations', () => {
+        let testRecordBondId2: string;
+
+        test('laconic cns bond dissociate --id <record_id>', async () => {
+          const result = spawnSync('laconic', ['cns', 'bond', 'dissociate', '--id', testRecordId]);
+          const outputObj = checkResultAndRetrieveOutput(result);
+
+          // Expected output
+          expect(outputObj).toEqual({ success: true });
+
+          const recordResult = spawnSync('laconic', ['cns', 'record', 'get', '--id', testRecordId]);
+          const recordOutputObj = checkResultAndRetrieveOutput(recordResult);
+
+          // Expected record
+          const expectedRecord = getRecordObj(testRecordFilePath, { bondId: '', recordId: testRecordId, names: null });
+
+          expect(recordOutputObj.length).toEqual(1);
+          expect(recordOutputObj[0]).toMatchObject(expectedRecord);
+
+        });
+
+        test('laconic cns bond associate --id <record_id> --bond-id <bond_id>', async () => {
+          // Create a new bond to be associated with the record
+          ({ bondId: testRecordBondId2 } = createBond(bondBalance));
+
+          const result = spawnSync('laconic', ['cns', 'bond', 'associate', '--id', testRecordId, '--bond-id', testRecordBondId2]);
+          const outputObj = checkResultAndRetrieveOutput(result);
+
+          // Expected output
+          expect(outputObj).toEqual({ success: true });
+
+          const recordResult = spawnSync('laconic', ['cns', 'record', 'get', '--id', testRecordId]);
+          const recordOutputObj = checkResultAndRetrieveOutput(recordResult);
+
+          // Expected record
+          const expectedRecord = getRecordObj(testRecordFilePath, { bondId: testRecordBondId2, recordId: testRecordId, names: null });
+
+          expect(recordOutputObj.length).toEqual(1);
+          expect(recordOutputObj[0]).toMatchObject(expectedRecord);
+        });
+
+        test('laconic cns bond records reassociate --old-bond-id <old_bond_id> --new-bond-id <new_bond_id>', async () => {
+          const result = spawnSync('laconic', ['cns', 'bond', 'records', 'reassociate', '--old-bond-id', testRecordBondId2, '--new-bond-id', testRecordBondId]);
+          const outputObj = checkResultAndRetrieveOutput(result);
+
+          // Expected output
+          expect(outputObj).toEqual({ success: true });
+
+          const recordResult = spawnSync('laconic', ['cns', 'record', 'get', '--id', testRecordId]);
+          const recordOutputObj = checkResultAndRetrieveOutput(recordResult);
+
+          // Expected record
+          const expectedRecord = getRecordObj(testRecordFilePath, { bondId: testRecordBondId, recordId: testRecordId, names: null });
+
+          expect(recordOutputObj.length).toEqual(1);
+          expect(recordOutputObj[0]).toMatchObject(expectedRecord);
+        });
+      });
+    });
+
+    describe('Name authority operations (pre auction)', () => {
+      test('laconic cns authority reserve <authority_name>', async () => {
+        const result = spawnSync('laconic', ['cns', 'authority', 'reserve', testAuthorityName]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expect result
+        expect(outputObj).toEqual({ success: true });
+      });
+
+      test('laconic cns authority whois <authority_name>', async () => {
+        const result = spawnSync('laconic', ['cns', 'authority', 'whois', testAuthorityName]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected authority (still in auction)
+        const expectedAuthority = getAuthorityObj({ owner: '', status: 'auction', auction: getAuctionObj({ owner: testAccount }) });
+
+        expect(outputObj.length).toEqual(1);
+        expect(outputObj[0]).toMatchObject(expectedAuthority);
+        expect(outputObj[0].expiryTime).toBeDefined();
+        expect(outputObj[0].height).toBeGreaterThan(0);
+
+        testAuctionId = outputObj[0].auction.id;
+      });
+    });
+
+    describe('Auction operations', () => {
+      const bidAmount = 25000000;
+      let bidRevealFilePath: string;
+
+      test('laconic cns auction get <auction_id>', async () => {
+        const result = spawnSync('laconic', ['cns', 'auction', 'get', testAuctionId]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected auction (still in commit stage)
+        const expectedAuction = getAuctionObj({ owner: testAccount, status: 'commit' });
+
+        expect(outputObj.length).toEqual(1);
+        expect(outputObj[0]).toMatchObject(expectedAuction);
+      });
+
+      test('laconic cns auction bid commit <auction_id> <quantity> <type>', async () => {
+        const result = spawnSync('laconic', ['cns', 'auction', 'bid', 'commit', testAuctionId, bidAmount.toString(), TOKEN_TYPE]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected output
+        expect(outputObj.reveal_file).toBeDefined();
+
+        bidRevealFilePath = outputObj.reveal_file;
+      });
+
+      test('laconic cns auction bid reveal <auction_id> <file_path>', async () => {
+        // Wait for auction commits duration (60s)
+        await delay(AUCTION_COMMIT_DURATION * 1000);
+
+        const auctionResult = spawnSync('laconic', ['cns', 'auction', 'get', testAuctionId]);
+        const auctionOutputObj = checkResultAndRetrieveOutput(auctionResult);
+
+        const expectedAuction = getAuctionObj({ owner: testAccount, status: 'reveal' });
+        const expectedBid = getBidObj({ bidder: testAccount });
+
+        expect(auctionOutputObj[0]).toMatchObject(expectedAuction);
+        expect(auctionOutputObj[0].bids[0]).toMatchObject(expectedBid);
+
+        // Reveal bid
+        const result = spawnSync('laconic', ['cns', 'auction', 'bid', 'reveal', testAuctionId, bidRevealFilePath]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected output
+        expect(outputObj).toEqual({ success: true });
+
+        const revealObject = JSON.parse(fs.readFileSync(bidRevealFilePath, 'utf8'));
+        expect(revealObject).toMatchObject({
+          chainId: CHAIN_ID,
+          auctionId: testAuctionId,
+          bidderAddress: testAccount,
+          bidAmount: `${bidAmount}aphoton`
+        });
+      }, (AUCTION_COMMIT_DURATION + 5) * 1000);
+    });
+
+    describe('Name authority operations (post auction)', () => {
+      const testSubAuthorityName = 'echo.laconic';
+      const testSubAuthorityName2 = 'kube.laconic';
+
+      test('laconic cns authority whois <authority_name>', async () => {
+        // Wait for auction reveals duration (60s)
+        await delay(AUCTION_REVEAL_DURATION * 1000);
+
+        const result = spawnSync('laconic', ['cns', 'authority', 'whois', testAuthorityName]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected authority (active)
+        const expectedAuthority = getAuthorityObj({ owner: testAccount, status: 'active', auction: null });
+
+        expect(outputObj.length).toEqual(1);
+        expect(outputObj[0]).toMatchObject(expectedAuthority);
+      }, (AUCTION_REVEAL_DURATION + 5) * 1000);
+
+      test('laconic cns authority bond set laconic <bond_id>', async () => {
+        // Create a new bond to be set on the authority
+        const bondBalance = 1000000000;
+        const { bondId } = createBond(bondBalance);
+
+        const result = spawnSync('laconic', ['cns', 'authority', 'bond', 'set', testAuthorityName, bondId]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected output
+        expect(outputObj).toEqual({ success: true });
+
+        // Check updated authority
+        const authorityResult = spawnSync('laconic', ['cns', 'authority', 'whois', testAuthorityName]);
+        const authorityOutputObj = checkResultAndRetrieveOutput(authorityResult);
+
+        // Expected authority (active with bond)
+        const expectedAuthority = getAuthorityObj({ owner: testAccount, status: 'active', auction: null, bondId: bondId });
+
+        expect(authorityOutputObj.length).toEqual(1);
+        expect(authorityOutputObj[0]).toMatchObject(expectedAuthority);
+      });
+
+      test('laconic cns authority reserve <sub_authority> (same owner)', async () => {
+        const result = spawnSync('laconic', ['cns', 'authority', 'reserve', testSubAuthorityName]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected output
+        expect(outputObj).toEqual({ success: true });
+
+        // Check updated authority
+        const authorityResult = spawnSync('laconic', ['cns', 'authority', 'whois', testSubAuthorityName]);
+        const authorityOutputObj = checkResultAndRetrieveOutput(authorityResult);
+
+        // Expected authority (active with bond)
+        const expectedAuthority = getAuthorityObj({ owner: testAccount, status: 'active', auction: null });
+
+        expect(authorityOutputObj.length).toEqual(1);
+        expect(authorityOutputObj[0]).toMatchObject(expectedAuthority);
+      });
+
+      test('laconic cns authority reserve <sub_authority> --owner <owner_address> (different owner)', async () => {
+        const result = spawnSync('laconic', ['cns', 'authority', 'reserve', testSubAuthorityName2, '--owner', testAccount2]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected output
+        expect(outputObj).toEqual({ success: true });
+
+        // Check updated authority
+        const authorityResult = spawnSync('laconic', ['cns', 'authority', 'whois', testSubAuthorityName2]);
+        const authorityOutputObj = checkResultAndRetrieveOutput(authorityResult);
+
+        // Expected authority (active with bond)
+        const expectedAuthority = getAuthorityObj({ owner: testAccount2, status: 'active', auction: null });
+
+        expect(authorityOutputObj.length).toEqual(1);
+        expect(authorityOutputObj[0]).toMatchObject(expectedAuthority);
+      });
+    });
+
+    describe('Name operations', () => {
+      const testName = 'crn://laconic/watcher/erc20';
+
+      test('laconic cns name set <name> <record_id>', async () => {
+        const result = spawnSync('laconic', ['cns', 'name', 'set', testName, testRecordId]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected output
+        expect(outputObj).toEqual({ success: true });
+      });
+
+      test('laconic cns name lookup <name>', async () => {
+        const result = spawnSync('laconic', ['cns', 'name', 'lookup', testName]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected output
+        expect(outputObj.length).toEqual(1);
+        expect(outputObj[0]).toMatchObject({ latest: { id: testRecordId } });
+      });
+
+      test('laconic cns name resolve <name>', async () => {
+        const result = spawnSync('laconic', ['cns', 'name', 'resolve', testName]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected resolved record
+        const expectedRecord = getRecordObj(testRecordFilePath, { bondId: testRecordBondId, recordId: testRecordId, names: [testName] });
+
+        expect(outputObj.length).toEqual(1);
+        expect(outputObj[0]).toMatchObject(expectedRecord);
+      });
+
+      test('laconic cns name delete <name>', async () => {
+        const result = spawnSync('laconic', ['cns', 'name', 'delete', testName]);
+        const outputObj = checkResultAndRetrieveOutput(result);
+
+        // Expected output
+        expect(outputObj).toEqual({ success: true });
+
+        // Check that name doesn't resolve
+        const resolveResult = spawnSync('laconic', ['cns', 'name', 'resolve', testName]);
+        const resolveOutputObj = checkResultAndRetrieveOutput(resolveResult);
+        expect(resolveOutputObj.length).toEqual(0);
+      });
+    });
+  });
+});

test/data/watcher-record.yml

@@ -0,0 +1,7 @@
+record:
+  type: WebsiteRegistrationRecord
+  url: 'https://cerc.io'
+  repo_registration_record_cid: QmSnuWmxptJZdLJpKRarxBMS2Ju2oANVrgbr2xWbie9b2D
+  build_artifact_cid: QmP8jTG1m9GSDJLCbeWhVSVgEzCPPwXRdCRuJtQ5Tz9Kc9
+  tls_cert_cid: QmbWqxBEKC3P8tqsKc98xmWNzrzDtRLMiMPL8wBuTGsMnR
+  version: 1.0.23

test/helpers.ts

@@ -0,0 +1,121 @@
+import fs from 'fs';
+import yaml from 'js-yaml';
+import { SpawnSyncReturns, spawnSync } from 'child_process';
+
+export const CHAIN_ID = 'laconic_9000-1';
+export const TOKEN_TYPE = 'aphoton';
+
+export const AUCTION_FEES = {
+  commit: 1000000,
+  reveal: 1000000,
+  minimumBid: 5000000
+};
+export const AUCTION_COMMIT_DURATION = 60; // 60s
+export const AUCTION_REVEAL_DURATION = 60; // 60s
+
+export function checkResultAndRetrieveOutput(result: SpawnSyncReturns<Buffer>): any {
+  expect(result.status).toBe(0);
+
+  const errorOutput = result.stderr.toString().trim();
+  expect(errorOutput).toBe('');
+
+  const output = result.stdout.toString().trim();
+  expect(output.length).toBeGreaterThan(0);
+
+  return JSON.parse(output);
+}
+
+export function createBond(quantity: number): { bondId: string } {
+  const result = spawnSync('laconic', ['cns', 'bond', 'create', '--type', TOKEN_TYPE, '--quantity', quantity.toString(), '--gas', '200000', '--fees', `200000${TOKEN_TYPE}`]);
+  const output = result.stdout.toString().trim();
+
+  return JSON.parse(output);
+}
+
+export function getBondObj(params: { id: string, owner: string, balance: number}): any {
+  return {
+    id: params.id,
+    owner: params.owner,
+    balance: [
+      {
+        type: TOKEN_TYPE,
+        quantity: params.balance
+      }
+    ]
+  };
+}
+
+export function getAccountObj(params: { address: string, balance?: number }): any {
+  const balanceObj: any = { type: TOKEN_TYPE };
+  if (params.balance) {
+    balanceObj.quantity = params.balance;
+  }
+
+  return {
+    address: params.address,
+    balance: [balanceObj]
+  };
+}
+
+export function getRecordObj(recordFilePath: string, params: { bondId: string, recordId: string, names: any }): any {
+  const recordContent = yaml.load(fs.readFileSync(recordFilePath, 'utf8')) as any;
+
+  return {
+    id: params.recordId,
+    names: params.names,
+    bondId: params.bondId,
+    attributes: recordContent.record
+  };
+}
+
+export function getAuthorityObj(params: { owner: string, status: string, auction: any, bondId?: string }): any {
+  return {
+    ownerAddress: params.owner,
+    status: params.status,
+    bondId: params.bondId || '',
+    auction: params.auction
+  };
+}
+
+export function getAuctionObj(params: { owner: string, status?: string }): any {
+  return {
+    status: params.status || 'commit',
+    ownerAddress: params.owner,
+    commitFee: {
+      type: TOKEN_TYPE,
+      quantity: AUCTION_FEES.commit
+    },
+    revealFee: {
+      type: TOKEN_TYPE,
+      quantity: AUCTION_FEES.reveal
+    },
+    minimumBid: {
+      type: TOKEN_TYPE,
+      quantity: AUCTION_FEES.minimumBid
+    },
+    winnerAddress: '',
+  };
+}
+
+export function getBidObj(params: { bidder: string, status?: string }): any {
+  return {
+    bidderAddress: params.bidder,
+    status: params.status || 'commit',
+    commitFee: {
+      type: TOKEN_TYPE,
+      quantity: AUCTION_FEES.commit
+    },
+    revealFee: {
+      type: TOKEN_TYPE,
+      quantity: AUCTION_FEES.reveal
+    },
+    bidAmount: {
+      type: '',
+      quantity: 0
+    }
+  };
+}
+
+export async function delay(ms: number): Promise<any> {
+  return new Promise(res => setTimeout(res, ms))
+}

test/run-tests.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+
+# Get the key from laconicd
+laconicd_key=$(yes | docker compose exec laconicd laconicd keys export mykey --unarmored-hex --unsafe)
+
+# Get the fixturenet account address
+laconicd_account_address=$(docker compose exec laconicd laconicd keys list | awk '/- address:/ {print $3}')
+
+# Set parameters for the test suite
+cosmos_chain_id=laconic_9000-1
+laconicd_rest_endpoint=http://127.0.0.1:1317
+laconicd_gql_endpoint=http://127.0.0.1:9473/api
+
+# Create the required config
+config_file="config.yml"
+config=$(cat <<EOL
+services:
+  cns:
+    restEndpoint: $laconicd_rest_endpoint
+    gqlEndpoint: $laconicd_gql_endpoint
+    userKey: $laconicd_key
+    bondId:
+    chainId: $cosmos_chain_id
+    gas: 200000
+    fees: 200000aphoton
+EOL
+)
+echo "$config" > "$config_file"
+
+# Wait for the laconid endpoint to come up
+docker compose exec laconicd sh -c "curl --retry 10 --retry-delay 3 --retry-connrefused http://127.0.0.1:9473/api"
+
+# Run tests
+TEST_ACCOUNT=$laconicd_account_address yarn test

tsconfig.json

@@ -97,5 +97,7 @@
     /* Completeness */
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
-  }
+  },
+  "include": ["src"],
+  "exclude": ["test"]
 }