Prathamesh Musale
12dd420a13
All checks were successful
Tests / cli_tests (18.x) (pull_request) Successful in 5m30s
312 lines
11 KiB
TypeScript
312 lines
11 KiB
TypeScript
import fs from 'fs';
|
|
import yaml from 'js-yaml';
|
|
import assert from 'assert';
|
|
import { SpawnSyncReturns, spawnSync } from 'child_process';
|
|
|
|
const TOKEN_TYPE = 'aphoton';
|
|
|
|
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:');
|
|
});
|
|
|
|
describe('laconic CNS commands', () => {
|
|
const initialAccountBalance = Number('100000000000000000000000000');
|
|
const testAccount = process.env.TEST_ACCOUNT;
|
|
const testAccount2 = 'ethm1vc62ysqu504at932jjq8pwrqgjt67rx6ggn5yu';
|
|
assert(testAccount, 'TEST_ACCOUNT not set in env');
|
|
|
|
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', 'laconic_9000-1');
|
|
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 bondBalance = 1000000000;
|
|
const bondOwner = testAccount;
|
|
let bondId: string;
|
|
|
|
test('laconic cns bond create', 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).toHaveProperty('bondId');
|
|
|
|
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);
|
|
});
|
|
});
|
|
|
|
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]).toHaveProperty('number');
|
|
expect(outputObj[0]).toHaveProperty('sequence');
|
|
|
|
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 recordFilePath = 'test/data/watcher-record.yml';
|
|
const gas = 250000;
|
|
const bondBalance = 1000000000;
|
|
let bondId: string;
|
|
let recordId: string;
|
|
|
|
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 } = createBond(bondBalance));
|
|
|
|
const result = spawnSync('laconic', ['cns', 'record', 'publish', '--filename', recordFilePath, '--bond-id', bondId, '--gas', gas.toString()]);
|
|
const outputObj = checkResultAndRetrieveOutput(result);
|
|
|
|
// Expect output object to resultant bond id
|
|
expect(outputObj).toHaveProperty('id');
|
|
|
|
recordId = outputObj.id;
|
|
});
|
|
|
|
test('laconic cns record list', async () => {
|
|
const result = spawnSync('laconic', ['cns', 'record', 'list']);
|
|
const outputObj = checkResultAndRetrieveOutput(result);
|
|
|
|
// Expected record
|
|
const expectedRecord = getRecordObj(recordFilePath, { bondId, recordId });
|
|
|
|
expect(outputObj.length).toEqual(1);
|
|
expect(outputObj[0]).toMatchObject(expectedRecord);
|
|
expect(outputObj[0]).toHaveProperty('createTime');
|
|
expect(outputObj[0]).toHaveProperty('expiryTime');
|
|
expect(outputObj[0]).toHaveProperty('owners');
|
|
expect(outputObj[0].owners.length).toEqual(1);
|
|
});
|
|
|
|
test('laconic cns record get --id <record_id>', async () => {
|
|
const result = spawnSync('laconic', ['cns', 'record', 'get', '--id', recordId]);
|
|
const outputObj = checkResultAndRetrieveOutput(result);
|
|
|
|
// Expected record
|
|
const expectedRecord = getRecordObj(recordFilePath, { bondId, recordId });
|
|
|
|
expect(outputObj.length).toEqual(1);
|
|
expect(outputObj[0]).toMatchObject(expectedRecord);
|
|
});
|
|
});
|
|
|
|
describe('Name authority operations', () => {
|
|
const authorityName = 'laconic';
|
|
|
|
test('laconic cns authority reserve <authority_name>', async () => {
|
|
const result = spawnSync('laconic', ['cns', 'authority', 'reserve', authorityName]);
|
|
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', authorityName]);
|
|
const outputObj = checkResultAndRetrieveOutput(result);
|
|
|
|
// Expected authority (still in auction)
|
|
const expectedAuthority = getAuthorityObj({ status: 'auction', auction: getAuctionObj({ owner: testAccount }) });
|
|
|
|
expect(outputObj.length).toEqual(1);
|
|
expect(outputObj[0]).toMatchObject(expectedAuthority);
|
|
expect(outputObj[0]).toHaveProperty('expiryTime');
|
|
expect(outputObj[0].height).toBeGreaterThan(0);
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
// Helper methods
|
|
|
|
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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
function getBondObj(params: { id: string, owner: string, balance: number}): any {
|
|
return {
|
|
id: params.id,
|
|
owner: params.owner,
|
|
balance: [
|
|
{
|
|
type: TOKEN_TYPE,
|
|
quantity: params.balance
|
|
}
|
|
]
|
|
};
|
|
}
|
|
|
|
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]
|
|
};
|
|
}
|
|
|
|
function getRecordObj(recordFilePath: string, params: { bondId: string, recordId: string }): any {
|
|
const recordContent = yaml.load(fs.readFileSync(recordFilePath, 'utf8')) as any;
|
|
|
|
return {
|
|
id: params.recordId,
|
|
names: null,
|
|
bondId: params.bondId,
|
|
attributes: recordContent.record
|
|
};
|
|
}
|
|
|
|
function getAuthorityObj(params: { status: string, auction: any }): any {
|
|
return {
|
|
ownerAddress: '',
|
|
ownerPublicKey: '',
|
|
status: params.status,
|
|
bondId: '',
|
|
auction: params.auction || null
|
|
};
|
|
}
|
|
|
|
function getAuctionObj(params: { owner: string, status?: string, bids?: any[] }): any {
|
|
const auctionFees = {
|
|
commit: 1000000,
|
|
reveal: 1000000,
|
|
minimumBid: 5000000
|
|
};
|
|
|
|
return {
|
|
status: params.status || 'commit',
|
|
ownerAddress: params.owner,
|
|
commitFee: {
|
|
type: TOKEN_TYPE,
|
|
quantity: auctionFees.commit
|
|
},
|
|
revealFee: {
|
|
type: TOKEN_TYPE,
|
|
quantity: auctionFees.reveal
|
|
},
|
|
minimumBid: {
|
|
type: TOKEN_TYPE,
|
|
quantity: auctionFees.minimumBid
|
|
},
|
|
winnerAddress: '',
|
|
bids: params.bids || []
|
|
};
|
|
}
|