mirror of
https://github.com/Xahau/xahau.js.git
synced 2026-08-23 16:40:52 +00:00
29e1423f84
when using a marker on an account request, a valid ledger_index or ledger_hash is required, otherwise the results can't be guaranteed to be reliable consolidated test values for addresses, indexes and hashes
498 lines
16 KiB
JavaScript
498 lines
16 KiB
JavaScript
var assert = require('assert');
|
|
var utils = require('./testutils');
|
|
|
|
var Remote = utils.load_module('remote').Remote;
|
|
var Server = utils.load_module('server').Server;
|
|
var Request = utils.load_module('request').Request;
|
|
|
|
var options, remote, callback, database, tx;
|
|
|
|
var ADDRESS = 'r4qLSAzv4LZ9TLsR7diphGwKnSEAMQTSjS';
|
|
var PEER_ADDRESS = 'rfYv1TXnwgDDK4WQNbFALykYuEBnrR4pDX';
|
|
var LEDGER_INDEX = 9592219;
|
|
var LEDGER_HASH = 'B4FD84A73DBD8F0DA9E320D137176EBFED969691DC0AAC7882B76B595A0841AE';
|
|
var PAGING_MARKER = '29F992CC252056BF690107D1E8F2D9FBAFF29FF107B62B1D1F4E4E11ADF2CC73';
|
|
|
|
|
|
describe('Remote', function () {
|
|
beforeEach(function () {
|
|
options = {
|
|
trace : true,
|
|
trusted: true,
|
|
local_signing: true,
|
|
|
|
servers: [
|
|
{ host: 's-west.ripple.com', port: 443, secure: true },
|
|
{ host: 's-east.ripple.com', port: 443, secure: true }
|
|
],
|
|
|
|
blobvault : 'https://blobvault.payward.com',
|
|
persistent_auth : false,
|
|
transactions_per_page: 50,
|
|
|
|
bridge: {
|
|
out: {
|
|
// 'bitcoin': 'localhost:3000'
|
|
// 'bitcoin': 'https://www.bitstamp.net/ripple/bridge/out/bitcoin/'
|
|
}
|
|
}
|
|
|
|
};
|
|
});
|
|
|
|
it('remote server initialization - url object', function() {
|
|
var remote = new Remote({
|
|
servers: [ { host: 's-west.ripple.com', port: 443, secure: true } ],
|
|
});
|
|
assert(Array.isArray(remote._servers));
|
|
assert(remote._servers[0] instanceof Server);
|
|
assert.strictEqual(remote._servers[0]._url, 'wss://s-west.ripple.com:443');
|
|
})
|
|
|
|
it('remote server initialization - url object - no secure property', function() {
|
|
var remote = new Remote({
|
|
servers: [ { host: 's-west.ripple.com', port: 443 } ]
|
|
});
|
|
assert(Array.isArray(remote._servers));
|
|
assert(remote._servers[0] instanceof Server);
|
|
assert.strictEqual(remote._servers[0]._url, 'wss://s-west.ripple.com:443');
|
|
})
|
|
|
|
it('remote server initialization - url object - secure: false', function() {
|
|
var remote = new Remote({
|
|
servers: [ { host: 's-west.ripple.com', port: 443, secure: false } ]
|
|
});
|
|
assert(Array.isArray(remote._servers));
|
|
assert(remote._servers[0] instanceof Server);
|
|
assert.strictEqual(remote._servers[0]._url, 'ws://s-west.ripple.com:443');
|
|
});
|
|
|
|
it('remote server initialization - url object - string port', function() {
|
|
var remote = new Remote({
|
|
servers: [ { host: 's-west.ripple.com', port: '443', secure: true } ]
|
|
});
|
|
assert(Array.isArray(remote._servers));
|
|
assert(remote._servers[0] instanceof Server);
|
|
assert.strictEqual(remote._servers[0]._url, 'wss://s-west.ripple.com:443');
|
|
})
|
|
|
|
it('remote server initialization - url object - invalid host', function() {
|
|
assert.throws(
|
|
function() {
|
|
var remote = new Remote({
|
|
servers: [ { host: '+', port: 443, secure: true } ]
|
|
});
|
|
}, Error);
|
|
})
|
|
|
|
it('remote server initialization - url object - invalid port', function() {
|
|
assert.throws(
|
|
function() {
|
|
var remote = new Remote({
|
|
servers: [ { host: 's-west.ripple.com', port: null, secure: true } ]
|
|
});
|
|
}, TypeError);
|
|
});
|
|
|
|
it('remote server initialization - url object - port out of range', function() {
|
|
assert.throws(
|
|
function() {
|
|
var remote = new Remote({
|
|
servers: [ { host: 's-west.ripple.com', port: 65537, secure: true } ]
|
|
});
|
|
}, Error);
|
|
});
|
|
|
|
it('remote server initialization - url string', function() {
|
|
var remote = new Remote({
|
|
servers: [ 'wss://s-west.ripple.com:443' ]
|
|
});
|
|
assert(Array.isArray(remote._servers));
|
|
assert(remote._servers[0] instanceof Server);
|
|
assert.strictEqual(remote._servers[0]._url, 'wss://s-west.ripple.com:443');
|
|
});
|
|
|
|
it('remote server initialization - url string - ws://', function() {
|
|
var remote = new Remote({
|
|
servers: [ 'ws://s-west.ripple.com:443' ]
|
|
});
|
|
assert(Array.isArray(remote._servers));
|
|
assert(remote._servers[0] instanceof Server);
|
|
assert.strictEqual(remote._servers[0]._url, 'ws://s-west.ripple.com:443');
|
|
});
|
|
|
|
it('remote server initialization - url string - invalid host', function() {
|
|
assert.throws(
|
|
function() {
|
|
var remote = new Remote({
|
|
servers: [ 'ws://+:443' ]
|
|
});
|
|
}, Error
|
|
);
|
|
});
|
|
|
|
it('remote server initialization - url string - invalid port', function() {
|
|
assert.throws(
|
|
function() {
|
|
var remote = new Remote({
|
|
servers: [ 'ws://s-west.ripple.com:null' ]
|
|
});
|
|
}, Error
|
|
);
|
|
});
|
|
|
|
it('remote server initialization - url string - port out of range', function() {
|
|
assert.throws(
|
|
function() {
|
|
var remote = new Remote({
|
|
servers: [ 'ws://s-west.ripple.com:65537:' ]
|
|
});
|
|
}, Error
|
|
);
|
|
});
|
|
|
|
describe('request constructors', function () {
|
|
beforeEach(function () {
|
|
callback = function () {}
|
|
remote = new Remote(options);
|
|
});
|
|
|
|
it('requesting a ledger', function () {
|
|
var request = remote.request_ledger(null, {}, callback);
|
|
assert(request instanceof Request);
|
|
});
|
|
|
|
it('requesting server info', function () {
|
|
var request = remote.request_server_info(null, {}, callback);
|
|
assert(request instanceof Request);
|
|
})
|
|
|
|
it('requesting peers', function () {
|
|
var request = remote.request_peers(null, {}, callback);
|
|
assert(request instanceof Request);
|
|
});
|
|
|
|
it('requesting a connection', function () {
|
|
var request = remote.request_connect(null, {}, callback);
|
|
assert(request instanceof Request);
|
|
});
|
|
|
|
it('making a unique node list add request', function () {
|
|
var request = remote.request_unl_add(null, {}, callback);
|
|
assert(request instanceof Request);
|
|
});
|
|
|
|
it('making a unique node list request', function () {
|
|
var request = remote.request_unl_list(null, {}, callback);
|
|
assert(request instanceof Request);
|
|
});
|
|
|
|
it('making a unique node list delete request', function () {
|
|
var request = remote.request_unl_delete(null, {}, callback);
|
|
assert(request instanceof Request);
|
|
});
|
|
|
|
it('request account currencies with ledger index', function() {
|
|
var request = remote.requestAccountCurrencies(ADDRESS);
|
|
assert.strictEqual(request.message.command, 'account_currencies');
|
|
assert.strictEqual(request.message.account, ADDRESS);
|
|
});
|
|
|
|
it('request account info with ledger index', function() {
|
|
var request = remote.requestAccountInfo(ADDRESS, {ledger: 9592219});
|
|
assert.strictEqual(request.message.command, 'account_info');
|
|
assert.strictEqual(request.message.account, ADDRESS);
|
|
assert.strictEqual(request.message.ledger_index, 9592219);
|
|
});
|
|
it('request account info with ledger hash', function() {
|
|
var request = remote.requestAccountInfo(ADDRESS, {ledger: LEDGER_HASH});
|
|
assert.strictEqual(request.message.command, 'account_info');
|
|
assert.strictEqual(request.message.account, ADDRESS);
|
|
assert.strictEqual(request.message.ledger_hash, LEDGER_HASH);
|
|
});
|
|
it('request account info with ledger identifier', function() {
|
|
var request = remote.requestAccountInfo(ADDRESS, {ledger: 'validated'});
|
|
assert.strictEqual(request.message.command, 'account_info');
|
|
assert.strictEqual(request.message.account, ADDRESS);
|
|
assert.strictEqual(request.message.ledger_index, 'validated');
|
|
});
|
|
|
|
it('request account balance with ledger index', function() {
|
|
var request = remote.requestAccountBalance(ADDRESS, 9592219);
|
|
assert.strictEqual(request.message.command, 'ledger_entry');
|
|
assert.strictEqual(request.message.account_root, ADDRESS);
|
|
assert.strictEqual(request.message.ledger_index, 9592219);
|
|
});
|
|
it('request account balance with ledger hash', function() {
|
|
var request = remote.requestAccountBalance(ADDRESS, LEDGER_HASH);
|
|
assert.strictEqual(request.message.command, 'ledger_entry');
|
|
assert.strictEqual(request.message.account_root, ADDRESS);
|
|
assert.strictEqual(request.message.ledger_hash, LEDGER_HASH);
|
|
});
|
|
it('request account balance with ledger identifier', function() {
|
|
var request = remote.requestAccountBalance(ADDRESS, 'validated');
|
|
assert.strictEqual(request.message.command, 'ledger_entry');
|
|
assert.strictEqual(request.message.account_root, ADDRESS);
|
|
assert.strictEqual(request.message.ledger_index, 'validated');
|
|
});
|
|
});
|
|
|
|
it('pagingAccountRequest', function() {
|
|
var request = Remote.accountRequest('account_lines', ADDRESS);
|
|
assert.deepEqual(request.message, {
|
|
command: 'account_lines',
|
|
id: undefined,
|
|
account: ADDRESS
|
|
});
|
|
});
|
|
|
|
it('pagingAccountRequest - limit', function() {
|
|
var request = Remote.accountRequest('account_lines', ADDRESS, {limit: 100});
|
|
assert.deepEqual(request.message, {
|
|
command: 'account_lines',
|
|
id: undefined,
|
|
account: ADDRESS,
|
|
limit: 100
|
|
});
|
|
});
|
|
|
|
it('pagingAccountRequest - limit, marker', function() {
|
|
var request = Remote.accountRequest('account_lines', ADDRESS, {limit: 100, marker: PAGING_MARKER, ledger: 9592219});
|
|
assert.deepEqual(request.message, {
|
|
command: 'account_lines',
|
|
id: undefined,
|
|
account: ADDRESS,
|
|
limit: 100,
|
|
marker: PAGING_MARKER,
|
|
ledger_index: 9592219
|
|
});
|
|
|
|
assert(!request.requested);
|
|
});
|
|
|
|
it('accountRequest - limit min', function() {
|
|
assert.strictEqual(Remote.accountRequest('account_lines', ADDRESS, {limit: 0}).message.limit, 0);
|
|
assert.strictEqual(Remote.accountRequest('account_lines', ADDRESS, {limit: -1}).message.limit, 0);
|
|
assert.strictEqual(Remote.accountRequest('account_lines', ADDRESS, {limit: -1e9}).message.limit, 0);
|
|
assert.strictEqual(Remote.accountRequest('account_lines', ADDRESS, {limit: -1e24}).message.limit, 0);
|
|
});
|
|
|
|
it('accountRequest - limit max', function() {
|
|
assert.strictEqual(Remote.accountRequest('account_lines', ADDRESS, {limit: 1e9}).message.limit, 1e9);
|
|
assert.strictEqual(Remote.accountRequest('account_lines', ADDRESS, {limit: 1e9+1}).message.limit, 1e9);
|
|
assert.strictEqual(Remote.accountRequest('account_lines', ADDRESS, {limit: 1e10}).message.limit, 1e9);
|
|
assert.strictEqual(Remote.accountRequest('account_lines', ADDRESS, {limit: 1e24}).message.limit, 1e9);
|
|
});
|
|
|
|
it('accountRequest - a valid ledger is required when using a marker', function() {
|
|
assert.throws(function() {
|
|
Remote.accountRequest('account_lines', ADDRESS, {marker: PAGING_MARKER})
|
|
},'A ledger_index or ledger_hash must be provided when using a marker');
|
|
|
|
assert.throws(function() {
|
|
Remote.accountRequest('account_lines', ADDRESS, {marker: PAGING_MARKER, ledger:'validated'})
|
|
},'A ledger_index or ledger_hash must be provided when using a marker');
|
|
|
|
assert.throws(function() {
|
|
Remote.accountRequest('account_lines', ADDRESS, {marker: PAGING_MARKER, ledger:NaN})
|
|
},'A ledger_index or ledger_hash must be provided when using a marker');
|
|
|
|
assert.throws(function() {
|
|
Remote.accountRequest('account_lines', ADDRESS, {marker: PAGING_MARKER, ledger:LEDGER_HASH.substr(0,63)})
|
|
},'A ledger_index or ledger_hash must be provided when using a marker');
|
|
|
|
assert.throws(function() {
|
|
Remote.accountRequest('account_lines', ADDRESS, {marker: PAGING_MARKER, ledger:LEDGER_HASH+'F'})
|
|
},'A ledger_index or ledger_hash must be provided when using a marker');
|
|
});
|
|
|
|
it('requestAccountLines, account and callback', function() {
|
|
var callback = function() {};
|
|
var remote = new Remote({
|
|
servers: [ { host: 's-west.ripple.com', port: 443, secure: true } ]
|
|
});
|
|
var request = remote.requestAccountLines(
|
|
ADDRESS,
|
|
callback
|
|
);
|
|
|
|
assert.deepEqual(request.message, {
|
|
command: 'account_lines',
|
|
id: undefined,
|
|
account: ADDRESS
|
|
});
|
|
|
|
assert(request.requested);
|
|
});
|
|
|
|
it('requestAccountLines, ledger, peer', function() {
|
|
var callback = function() {};
|
|
var remote = new Remote({
|
|
servers: [ { host: 's-west.ripple.com', port: 443, secure: true } ]
|
|
});
|
|
var request = remote.requestAccountLines(
|
|
ADDRESS,
|
|
{
|
|
ledger: LEDGER_HASH,
|
|
peer: PEER_ADDRESS
|
|
},
|
|
callback
|
|
);
|
|
|
|
assert.deepEqual(request.message, {
|
|
command: 'account_lines',
|
|
id: undefined,
|
|
account: ADDRESS,
|
|
ledger_hash: LEDGER_HASH,
|
|
peer: PEER_ADDRESS
|
|
});
|
|
|
|
assert(request.requested);
|
|
});
|
|
|
|
it('requestAccountLines, ledger, peer, limit and marker', function() {
|
|
var callback = function() {};
|
|
var remote = new Remote({
|
|
servers: [ { host: 's-west.ripple.com', port: 443, secure: true } ]
|
|
});
|
|
var request = remote.requestAccountLines(
|
|
ADDRESS,
|
|
{
|
|
ledger: LEDGER_INDEX,
|
|
peer: PEER_ADDRESS,
|
|
limit: 200,
|
|
marker: PAGING_MARKER
|
|
},
|
|
callback
|
|
);
|
|
|
|
assert.deepEqual(request.message, {
|
|
command: 'account_lines',
|
|
id: undefined,
|
|
account: ADDRESS,
|
|
ledger_index: LEDGER_INDEX,
|
|
peer: PEER_ADDRESS,
|
|
limit: 200,
|
|
marker: PAGING_MARKER
|
|
});
|
|
|
|
assert(request.requested);
|
|
});
|
|
|
|
it('requestAccountOffers, ledger, peer, limit and marker', function() {
|
|
var callback = function() {};
|
|
var remote = new Remote({
|
|
servers: [ { host: 's-west.ripple.com', port: 443, secure: true } ]
|
|
});
|
|
var request = remote.requestAccountOffers(
|
|
ADDRESS,
|
|
{
|
|
ledger: LEDGER_HASH,
|
|
peer: PEER_ADDRESS,
|
|
limit: 32,
|
|
marker: PAGING_MARKER
|
|
},
|
|
callback
|
|
);
|
|
|
|
assert.deepEqual(request.message, {
|
|
command: 'account_offers',
|
|
id: undefined,
|
|
account: ADDRESS,
|
|
ledger_hash: LEDGER_HASH,
|
|
peer: PEER_ADDRESS,
|
|
limit: 32,
|
|
marker: PAGING_MARKER
|
|
});
|
|
|
|
assert(request.requested);
|
|
});
|
|
|
|
it('create remote and get pending transactions', function() {
|
|
before(function() {
|
|
tx = [{
|
|
tx_json: {
|
|
Account : "r4qLSAzv4LZ9TLsR7diphGwKnSEAMQTSjS",
|
|
Amount : {
|
|
currency : "LTC",
|
|
issuer : "r4qLSAzv4LZ9TLsR7diphGwKnSEAMQTSjS",
|
|
value : "9.985"
|
|
},
|
|
Destination : "r4qLSAzv4LZ9TLsR7diphGwKnSEAMQTSjS",
|
|
Fee : "15",
|
|
Flags : 0,
|
|
Paths : [
|
|
[
|
|
{
|
|
account : "rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q",
|
|
currency : "USD",
|
|
issuer : "rMwjYedjc7qqtKYVLiAccJSmCwih4LnE2q",
|
|
type : 49,
|
|
type_hex : "0000000000000031"
|
|
},
|
|
{
|
|
currency : "LTC",
|
|
issuer : "rfYv1TXnwgDDK4WQNbFALykYuEBnrR4pDX",
|
|
type : 48,
|
|
type_hex : "0000000000000030"
|
|
},
|
|
{
|
|
account : "rfYv1TXnwgDDK4WQNbFALykYuEBnrR4pDX",
|
|
currency : "LTC",
|
|
issuer : "rfYv1TXnwgDDK4WQNbFALykYuEBnrR4pDX",
|
|
type : 49,
|
|
type_hex : "0000000000000031"
|
|
}
|
|
]
|
|
],
|
|
SendMax : {
|
|
currency : "USD",
|
|
issuer : "r4qLSAzv4LZ9TLsR7diphGwKnSEAMQTSjS",
|
|
value : "30.30993068"
|
|
},
|
|
Sequence : 415,
|
|
SigningPubKey : "02854B06CE8F3E65323F89260E9E19B33DA3E01B30EA4CA172612DE77973FAC58A",
|
|
TransactionType : "Payment",
|
|
TxnSignature : "304602210096C2F385530587DE573936CA51CB86B801A28F777C944E268212BE7341440B7F022100EBF0508A9145A56CDA7FAF314DF3BBE51C6EE450BA7E74D88516891A3608644E"
|
|
},
|
|
clientID: '48631',
|
|
state: 'pending',
|
|
submitIndex: 1,
|
|
submittedIDs: ["304602210096C2F385530587DE573936CA51CB86B801A28F777C944E268212BE7341440B7F022100EBF0508A9145A56CDA7FAF314DF3BBE51C6EE450BA7E74D88516891A3608644E"],
|
|
secret: 'mysecret'
|
|
}];
|
|
database = {
|
|
getPendingTransactions: function(callback) {
|
|
callback(null, tx);
|
|
}
|
|
}
|
|
});
|
|
|
|
it('should set transaction members correct ', function(done) {
|
|
remote = new Remote(options);
|
|
remote.storage = database;
|
|
remote.transaction = function() {
|
|
return {
|
|
clientID: function(id) {
|
|
if (typeof id === 'string') {
|
|
this._clientID = id;
|
|
}
|
|
return this;
|
|
},
|
|
submit: function() {
|
|
assert.deepEqual(this._clientID, tx[0].clientID);
|
|
assert.deepEqual(this.submittedIDs,[tx[0].tx_json.TxnSignature]);
|
|
assert.equal(this.submitIndex, tx[0].submitIndex);
|
|
assert.equal(this.secret, tx[0].secret);
|
|
done();
|
|
|
|
},
|
|
parseJson: function(json) {}
|
|
}
|
|
}
|
|
remote.getPendingTransactions();
|
|
|
|
})
|
|
})
|
|
})
|