mirror of
https://github.com/Xahau/xahau.js.git
synced 2025-11-20 04:05:52 +00:00
357 lines
11 KiB
JavaScript
357 lines
11 KiB
JavaScript
/* eslint-disable max-nested-callbacks */
|
|
'use strict';
|
|
const _ = require('lodash');
|
|
const assert = require('assert');
|
|
const Account = require('ripple-lib').Account;
|
|
|
|
const addresses = require('./fixtures/addresses');
|
|
const fixtures = require('./fixtures/api');
|
|
const accountLinesResponse = require('./fixtures/api/rippled/account-lines');
|
|
|
|
const setupAPI = require('./setup-api');
|
|
|
|
|
|
function createRemote(remoteOptions = {}) {
|
|
return {
|
|
on: function() {},
|
|
requestAccountInfo: function(options, callback) {
|
|
if (options.account === 'rLdfp6eoR948KVxfn6EpaaNTKwfwXhzSeQ') {
|
|
callback({
|
|
error: 'remoteError',
|
|
error_message: 'Remote reported an error.',
|
|
remote: {
|
|
account: 'rLdfp6eoR948KVxfn6EpaaNTKwfwXhzSeQ',
|
|
error: 'actNotFound',
|
|
error_code: 15,
|
|
error_message: 'Account not found.',
|
|
id: 3,
|
|
ledger_current_index: 6391106,
|
|
request: {
|
|
account: 'rLdfp6eoR948KVxfn6EpaaNTKwfwXhzSeQ',
|
|
command: 'account_info',
|
|
id: 3,
|
|
ident: 'rLdfp6eoR948KVxfn6EpaaNTKwfwXhzSeQ'
|
|
},
|
|
status: 'error',
|
|
type: 'response'
|
|
},
|
|
result: 'remoteError',
|
|
engine_result: 'remoteError',
|
|
result_message: 'Remote reported an error.',
|
|
engine_result_message: 'Remote reported an error.',
|
|
message: 'Remote reported an error.'
|
|
});
|
|
} else if (options.account === 'rKXCummUHnenhYudNb9UoJ4mGBR75vFcgz') {
|
|
callback(null, {
|
|
account_data:
|
|
_.assign({
|
|
Account: 'rKXCummUHnenhYudNb9UoJ4mGBR75vFcgz',
|
|
Flags: parseInt(65536 | 0x00100000, 10),
|
|
LedgerEntryType: 'AccountRoot',
|
|
RegularKey: 'rNw4ozCG514KEjPs5cDrqEcdsi31Jtfm5r'
|
|
}, remoteOptions)
|
|
});
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
describe('Account', function() {
|
|
|
|
describe('mocked', function() {
|
|
beforeEach(setupAPI.setup);
|
|
afterEach(setupAPI.teardown);
|
|
|
|
// this test is artificial, just to increase coverage
|
|
// because code inside listenerRemoved function in Account object
|
|
// will never be called in normal situation
|
|
// (Account object is subscribed to own events, so _subs counter never
|
|
// reach zero)
|
|
it('unsubscribe ', function(done) {
|
|
const account = new Account(this.api.remote, addresses.ACCOUNT);
|
|
this.mockRippled.expect({
|
|
request_subscribe: 1,
|
|
request_unsubscribe: 1,
|
|
request_account_info: 1
|
|
});
|
|
function dumb() {}
|
|
account.on('entry', dumb);
|
|
account._subs -= 1;
|
|
account.removeListener('entry', dumb);
|
|
setTimeout(() => {
|
|
done();
|
|
}, 100);
|
|
});
|
|
|
|
it('toJson', function() {
|
|
const account = new Account(this.api.remote, addresses.ACCOUNT);
|
|
const json = account.toJson();
|
|
assert.strictEqual(json, addresses.ACCOUNT);
|
|
});
|
|
|
|
it('entry', function(done) {
|
|
const account = new Account(this.api.remote, addresses.ACCOUNT);
|
|
account.entry((error, info) => {
|
|
assert.deepEqual(info, fixtures.rippled.account_info.normal.result);
|
|
done(error);
|
|
});
|
|
});
|
|
|
|
it('entry error', function(done) {
|
|
const account = new Account(this.api.remote, addresses.NOTFOUND);
|
|
account.entry((error) => {
|
|
assert(error);
|
|
error.remote.id = 0;
|
|
assert.deepEqual(error.remote, fixtures.rippled.account_info.notfound);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('getNextSequence not found', function(done) {
|
|
const account = new Account(this.api.remote, addresses.NOTFOUND);
|
|
account.getNextSequence((error, sequence) => {
|
|
assert.strictEqual(sequence, 1);
|
|
done(error);
|
|
});
|
|
});
|
|
|
|
it('lines', function(done) {
|
|
const account = new Account(this.api.remote, addresses.ACCOUNT);
|
|
account.lines((error, lines) => {
|
|
assert(lines);
|
|
const expected = JSON.parse(accountLinesResponse.normal({}))
|
|
.result.lines;
|
|
assert.deepEqual(lines.lines, expected);
|
|
done(error);
|
|
});
|
|
});
|
|
|
|
it('line', function(done) {
|
|
const account = new Account(this.api.remote, addresses.ACCOUNT);
|
|
account.line('015841551A748AD2C1F76FF6ECB0CCCD00000000',
|
|
'rs9M85karFkCRjvc6KMWn8Coigm9cbcgcx', (error, line) => {
|
|
const expected = JSON.parse(accountLinesResponse.normal({}))
|
|
.result.lines[22];
|
|
assert.deepEqual(line, expected);
|
|
done(error);
|
|
});
|
|
});
|
|
|
|
it('line when account not found', function(done) {
|
|
const account = new Account(this.api.remote, addresses.NOTFOUND);
|
|
account.line('', 'rs9M85karFkCRjvc6KMWn8Coigm9cbcgcx', (error) => {
|
|
assert(error);
|
|
error.remote.id = 0;
|
|
assert.deepEqual(error.remote, fixtures.rippled.account_info.notfound);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('submit ', function(done) {
|
|
const account = new Account(this.api.remote, addresses.ACCOUNT);
|
|
account._transactionManager.submit = function() {
|
|
done();
|
|
};
|
|
account.submit({});
|
|
});
|
|
|
|
// this one just for coverage - _subs can't be zero
|
|
it('notify - no subscribers ', function(done) {
|
|
const account = new Account(this.api.remote, addresses.ACCOUNT);
|
|
let fired = false;
|
|
account.on('transaction', function() {
|
|
fired = true;
|
|
});
|
|
account._subs = 0;
|
|
account.notify({});
|
|
|
|
setTimeout(() => {
|
|
assert(!fired);
|
|
done();
|
|
}, 100);
|
|
});
|
|
|
|
it('notify - transaction without account field ', function(done) {
|
|
const account = new Account(this.api.remote, addresses.ACCOUNT);
|
|
let transactionFired;
|
|
let transactionInboundFired = false;
|
|
account.on('transaction', function(transaction) {
|
|
transactionFired = transaction;
|
|
});
|
|
account.on('transaction-inbound', function() {
|
|
transactionInboundFired = true;
|
|
});
|
|
account.notify({transaction: {}});
|
|
|
|
setTimeout(() => {
|
|
assert.deepEqual(transactionFired, {transaction: {}});
|
|
assert(!transactionInboundFired);
|
|
done();
|
|
}, 100);
|
|
});
|
|
|
|
it('notify - transaction-inbound', function(done) {
|
|
const account = new Account(this.api.remote, addresses.ACCOUNT);
|
|
account.on('transaction-inbound', function(transaction) {
|
|
assert.deepEqual(transaction,
|
|
{transaction: {Account: addresses.NOTFOUND}});
|
|
done();
|
|
});
|
|
account.notify({transaction: {Account: addresses.NOTFOUND}});
|
|
});
|
|
|
|
});
|
|
|
|
describe('#_publicKeyToAddress()', function() {
|
|
|
|
it('should throw an error if the key is invalid', function() {
|
|
try {
|
|
Account._publicKeyToAddress('not a real key');
|
|
} catch (e) {
|
|
assert(e);
|
|
}
|
|
});
|
|
|
|
it('should return unchanged a valid UINT160', function() {
|
|
assert.strictEqual(
|
|
Account._publicKeyToAddress('rKXCummUHnenhYudNb9UoJ4mGBR75vFcgz'),
|
|
'rKXCummUHnenhYudNb9UoJ4mGBR75vFcgz');
|
|
});
|
|
|
|
it('should parse a hex-encoded public key as a UINT160', function() {
|
|
assert.strictEqual(
|
|
Account._publicKeyToAddress(
|
|
'025B32A54BFA33FB781581F49B235C0E2820C929FF41E677ADA5D3E53CFBA46332'),
|
|
'rKXCummUHnenhYudNb9UoJ4mGBR75vFcgz');
|
|
|
|
assert.strictEqual(
|
|
Account._publicKeyToAddress(
|
|
'03BFA879C00D58CF55F2B5975FF9B5293008FF49BEFB3EE6BEE2814247BF561A23'),
|
|
'rLpq5RcRzA8FU1yUqEPW4xfsdwon7casuM');
|
|
|
|
assert.strictEqual(
|
|
Account._publicKeyToAddress(
|
|
'02DF0AB18930B6410CA9F55CB37541F1FED891B8EDF8AB1D01D8F23018A4B204A7'),
|
|
'rP4yWwjoDGF2iZSBdAQAgpC449YDezEbT1');
|
|
|
|
assert(
|
|
Account._publicKeyToAddress(
|
|
'0310C451A40CAFFD39D6B8A3BD61BF65BCA55246E9DABC3170EBE431D30655B61F'),
|
|
'rLdfp6eoR948KVxfn6EpaaNTKwfwXhzSeQ');
|
|
});
|
|
|
|
});
|
|
|
|
// XXX: clean up the stubbed out remote methods
|
|
|
|
describe('#publicKeyIsActive()', function() {
|
|
|
|
it('should respond true if the public key corresponds to the account ' +
|
|
' address and the master key IS NOT disabled', function(done) {
|
|
|
|
const options = {Flags: 65536};
|
|
const account = new Account(createRemote(options),
|
|
'rKXCummUHnenhYudNb9UoJ4mGBR75vFcgz');
|
|
account.publicKeyIsActive(
|
|
'025B32A54BFA33FB781581F49B235C0E2820C929FF41E677ADA5D3E53CFBA46332',
|
|
function(err, is_valid) {
|
|
|
|
assert(err === null);
|
|
assert(is_valid === true);
|
|
done();
|
|
});
|
|
|
|
});
|
|
|
|
it('should respond false if the public key corresponds to the account ' +
|
|
' address and the master key IS disabled', function(done) {
|
|
|
|
const account = new Account(createRemote(),
|
|
'rKXCummUHnenhYudNb9UoJ4mGBR75vFcgz');
|
|
account.publicKeyIsActive(
|
|
'025B32A54BFA33FB781581F49B235C0E2820C929FF41E677ADA5D3E53CFBA46332',
|
|
function(err, is_valid) {
|
|
|
|
assert(err === null);
|
|
assert(is_valid === false);
|
|
done();
|
|
});
|
|
|
|
});
|
|
|
|
it('should respond true if the public key corresponds to the regular key',
|
|
function(done) {
|
|
|
|
const account = new Account(createRemote(),
|
|
'rKXCummUHnenhYudNb9UoJ4mGBR75vFcgz');
|
|
account.publicKeyIsActive(
|
|
'02BE53B7ACBB0900E0BB7729C9CAC1033A0137993B17800BD1191BBD1B29D96A8C',
|
|
function(err, is_valid) {
|
|
|
|
assert(err === null);
|
|
assert(is_valid === true);
|
|
done();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
it('should respond false if the public key does not correspond to an ' +
|
|
' active public key for the account', function(done) {
|
|
|
|
const account = new Account(createRemote(),
|
|
'rKXCummUHnenhYudNb9UoJ4mGBR75vFcgz');
|
|
account.publicKeyIsActive(
|
|
'032ECDA93970BC7E8872EF6582CB52A5557F117244A949EB4FA8AC7688CF24FBC8',
|
|
function(err, is_valid) {
|
|
assert(err === null);
|
|
assert(is_valid === false);
|
|
done();
|
|
});
|
|
|
|
});
|
|
|
|
it('should respond false if the public key is invalid', function(done) {
|
|
|
|
const account = new Account(createRemote(),
|
|
'rKXCummUHnenhYudNb9UoJ4mGBR75vFcgz');
|
|
account.publicKeyIsActive('not a real public key', err => {
|
|
assert(err);
|
|
done();
|
|
});
|
|
|
|
});
|
|
|
|
it('should assume the master key is valid for unfunded accounts', done => {
|
|
|
|
const account = new Account(createRemote(),
|
|
'rLdfp6eoR948KVxfn6EpaaNTKwfwXhzSeQ');
|
|
account.publicKeyIsActive(
|
|
'0310C451A40CAFFD39D6B8A3BD61BF65BCA55246E9DABC3170EBE431D30655B61F',
|
|
function(err, is_valid) {
|
|
assert(!err);
|
|
assert(is_valid);
|
|
done();
|
|
});
|
|
|
|
});
|
|
|
|
it('should respond false if the public key does not correspond to an ' +
|
|
' active public key for the unfunded account', function(done) {
|
|
|
|
const account = new Account(createRemote(),
|
|
'rLdfp6eoR948KVxfn6EpaaNTKwfwXhzSeQ');
|
|
account.publicKeyIsActive(
|
|
'032ECDA93970BC7E8872EF6582CB52A5557F117244A949EB4FA8AC7688CF24FBC8',
|
|
function(err, is_valid) {
|
|
assert(err === null);
|
|
assert(is_valid === false);
|
|
done();
|
|
});
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|