550 lines
11 KiB
JavaScript
550 lines
11 KiB
JavaScript
'use strict';
|
|
|
|
var expect = require('chai').expect;
|
|
var spawn = require('child_process').spawn;
|
|
var rimraf = require('rimraf');
|
|
var mkdirp = require('mkdirp');
|
|
var fs = require('fs');
|
|
var async = require('async');
|
|
var RPC = require('florincoind-rpc');
|
|
var http = require('http');
|
|
|
|
var rpc1Address;
|
|
var rpc2Address;
|
|
var tx1;
|
|
var tx2;
|
|
var block;
|
|
|
|
var rpcConfig = {
|
|
protocol: 'http',
|
|
user: 'local',
|
|
pass: 'localtest',
|
|
host: '127.0.0.1',
|
|
port: 58332,
|
|
rejectUnauthorized: false
|
|
};
|
|
|
|
var rpc1 = new RPC(rpcConfig);
|
|
rpcConfig.port++;
|
|
var rpc2 = new RPC(rpcConfig);
|
|
var debug = true;
|
|
var flocoreDataDir = '/tmp/flocore';
|
|
var florincoinDataDirs = ['/tmp/florincoin1', '/tmp/florincoin2'];
|
|
|
|
var florincoin = {
|
|
args: {
|
|
datadir: null,
|
|
listen: 1,
|
|
regtest: 1,
|
|
server: 1,
|
|
rpcuser: 'local',
|
|
rpcpassword: 'localtest',
|
|
//printtoconsole: 1
|
|
rpcport: 58332,
|
|
},
|
|
datadir: null,
|
|
exec: 'florincoind', //if this isn't on your PATH, then provide the absolute path, e.g. /usr/local/bin/florincoind
|
|
processes: []
|
|
};
|
|
|
|
var flocore = {
|
|
configFile: {
|
|
file: flocoreDataDir + '/flocore-node.json',
|
|
conf: {
|
|
network: 'regtest',
|
|
port: 53001,
|
|
datadir: flocoreDataDir,
|
|
services: [
|
|
'p2p',
|
|
'db',
|
|
'header',
|
|
'block',
|
|
'address',
|
|
'transaction',
|
|
'mempool',
|
|
'web',
|
|
'flosight-api',
|
|
'fee',
|
|
'timestamp'
|
|
],
|
|
servicesConfig: {
|
|
'p2p': {
|
|
'peers': [
|
|
{ 'ip': { 'v4': '127.0.0.1' }, port: 18444 }
|
|
]
|
|
},
|
|
'fee': {
|
|
'rpc': {
|
|
'user': 'local',
|
|
'pass': 'localtest',
|
|
'host': 'localhost',
|
|
'protocol': 'http',
|
|
'port': 58332
|
|
}
|
|
},
|
|
'flosight-api': {
|
|
'routePrefix': 'api'
|
|
}
|
|
}
|
|
}
|
|
},
|
|
httpOpts: {
|
|
protocol: 'http:',
|
|
hostname: 'localhost',
|
|
port: 53001,
|
|
},
|
|
opts: { cwd: flocoreDataDir },
|
|
datadir: flocoreDataDir,
|
|
exec: 'flocored',
|
|
args: ['start'],
|
|
process: null
|
|
};
|
|
|
|
var startFlorincoind = function(count, callback) {
|
|
|
|
var listenCount = 0;
|
|
async.timesSeries(count, function(n, next) {
|
|
|
|
var datadir = florincoinDataDirs.shift();
|
|
|
|
florincoin.datadir = datadir;
|
|
florincoin.args.datadir = datadir;
|
|
|
|
if (listenCount++ > 0) {
|
|
florincoin.args.listen = 0;
|
|
florincoin.args.rpcport++;
|
|
florincoin.args.connect = '127.0.0.1';
|
|
}
|
|
|
|
rimraf(datadir, function(err) {
|
|
|
|
if(err) {
|
|
return next(err);
|
|
}
|
|
|
|
mkdirp(datadir, function(err) {
|
|
|
|
if(err) {
|
|
return next(err);
|
|
}
|
|
|
|
var args = florincoin.args;
|
|
var argList = Object.keys(args).map(function(key) {
|
|
return '-' + key + '=' + args[key];
|
|
});
|
|
|
|
var florincoinProcess = spawn(florincoin.exec, argList, florincoin.opts);
|
|
florincoin.processes.push(florincoinProcess);
|
|
|
|
florincoinProcess.stdout.on('data', function(data) {
|
|
|
|
if (debug) {
|
|
process.stdout.write(data.toString());
|
|
}
|
|
|
|
});
|
|
|
|
florincoinProcess.stderr.on('data', function(data) {
|
|
|
|
if (debug) {
|
|
process.stderr.write(data.toString());
|
|
}
|
|
|
|
});
|
|
|
|
next();
|
|
|
|
});
|
|
|
|
});
|
|
}, function(err) {
|
|
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
|
|
var pids = florincoin.processes.map(function(process) {
|
|
return process.pid;
|
|
});
|
|
|
|
console.log(count + ' florincoind\'s started at pid(s): ' + pids);
|
|
callback();
|
|
});
|
|
};
|
|
|
|
|
|
var shutdownFlorincoind = function(callback) {
|
|
florincoin.processes.forEach(function(process) {
|
|
process.kill();
|
|
});
|
|
setTimeout(callback, 3000);
|
|
};
|
|
|
|
var shutdownFlocore = function(callback) {
|
|
if (flocore.process) {
|
|
flocore.process.kill();
|
|
}
|
|
callback();
|
|
};
|
|
|
|
|
|
var buildInitialChain = function(callback) {
|
|
async.waterfall([
|
|
function(next) {
|
|
console.log('checking to see if florincoind\'s are connected to each other.');
|
|
rpc1.getinfo(function(err, res) {
|
|
if (err || res.result.connections !== 1) {
|
|
next(err || new Error('florincoind\'s not connected to each other.'));
|
|
}
|
|
next();
|
|
});
|
|
},
|
|
function(next) {
|
|
console.log('generating 101 blocks');
|
|
rpc1.generate(101, next);
|
|
},
|
|
function(res, next) {
|
|
console.log('getting new address from rpc2');
|
|
rpc2.getNewAddress(function(err, res) {
|
|
if (err) {
|
|
return next(err);
|
|
}
|
|
rpc2Address = res.result;
|
|
console.log(rpc2Address);
|
|
next(null, rpc2Address);
|
|
});
|
|
},
|
|
function(addr, next) {
|
|
rpc1.sendToAddress(rpc2Address, 25, next);
|
|
},
|
|
function(res, next) {
|
|
tx1 = res.result;
|
|
console.log('TXID: ' + res.result);
|
|
console.log('generating 7 blocks');
|
|
rpc1.generate(7, next);
|
|
},
|
|
function(res, next) {
|
|
block = res.result[res.result.length - 1];
|
|
rpc2.getBalance(function(err, res) {
|
|
console.log(res);
|
|
next();
|
|
});
|
|
},
|
|
function(next) {
|
|
console.log('getting new address from rpc1');
|
|
rpc1.getNewAddress(function(err, res) {
|
|
if (err) {
|
|
return next(err);
|
|
}
|
|
rpc1Address = res.result;
|
|
next(null, rpc1Address);
|
|
});
|
|
},
|
|
function(addr, next) {
|
|
rpc2.sendToAddress(rpc1Address, 20, next);
|
|
},
|
|
function(res, next) {
|
|
tx2 = res.result;
|
|
console.log('sending from rpc2Address TXID: ', res);
|
|
console.log('generating 6 blocks');
|
|
rpc2.generate(6, next);
|
|
}
|
|
], function(err) {
|
|
|
|
if (err) {
|
|
return callback(err);
|
|
}
|
|
rpc1.getInfo(function(err, res) {
|
|
console.log(res);
|
|
callback();
|
|
});
|
|
});
|
|
|
|
};
|
|
|
|
var startFlocore = function(callback) {
|
|
|
|
rimraf(flocoreDataDir, function(err) {
|
|
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
|
|
mkdirp(flocoreDataDir, function(err) {
|
|
|
|
if(err) {
|
|
return callback(err);
|
|
}
|
|
|
|
fs.writeFileSync(flocore.configFile.file, JSON.stringify(flocore.configFile.conf));
|
|
|
|
var args = flocore.args;
|
|
flocore.process = spawn(flocore.exec, args, flocore.opts);
|
|
|
|
flocore.process.stdout.on('data', function(data) {
|
|
|
|
if (debug) {
|
|
process.stdout.write(data.toString());
|
|
}
|
|
|
|
});
|
|
flocore.process.stderr.on('data', function(data) {
|
|
|
|
if (debug) {
|
|
process.stderr.write(data.toString());
|
|
}
|
|
|
|
});
|
|
|
|
callback();
|
|
});
|
|
|
|
});
|
|
|
|
|
|
};
|
|
|
|
describe('Status', function() {
|
|
|
|
this.timeout(60000);
|
|
|
|
before(function(done) {
|
|
|
|
async.series([
|
|
function(next) {
|
|
startFlorincoind(2, next);
|
|
},
|
|
function(next) {
|
|
setTimeout(function() {
|
|
buildInitialChain(next);
|
|
}, 8000);
|
|
},
|
|
function(next) {
|
|
setTimeout(function() {
|
|
startFlocore(next);
|
|
}, 6000);
|
|
}
|
|
], function(err) {
|
|
if (err) {
|
|
return done(err);
|
|
}
|
|
setTimeout(done, 2000);
|
|
});
|
|
|
|
});
|
|
|
|
after(function(done) {
|
|
shutdownFlocore(function() {
|
|
shutdownFlorincoind(done);
|
|
});
|
|
});
|
|
|
|
it('should get status: /status', function(done) {
|
|
|
|
var request = http.request('http://localhost:53001/api/status', function(res) {
|
|
|
|
var error;
|
|
if (res.statusCode !== 200 && res.statusCode !== 201) {
|
|
|
|
if (error) {
|
|
return;
|
|
}
|
|
|
|
return done('Error from flocore-node webserver: ' + res.statusCode);
|
|
|
|
}
|
|
|
|
var resError;
|
|
var resData = '';
|
|
|
|
res.on('error', function(e) {
|
|
resError = e;
|
|
});
|
|
|
|
res.on('data', function(data) {
|
|
resData += data;
|
|
});
|
|
|
|
res.on('end', function() {
|
|
if (error) {
|
|
return;
|
|
}
|
|
var data = JSON.parse(resData);
|
|
expect(data.info).to.not.be.null;
|
|
done();
|
|
});
|
|
|
|
});
|
|
request.write('');
|
|
request.end();
|
|
});
|
|
|
|
it('should get status: /sync', function(done) {
|
|
|
|
var request = http.request('http://localhost:53001/api/sync', function(res) {
|
|
|
|
var error;
|
|
if (res.statusCode !== 200 && res.statusCode !== 201) {
|
|
|
|
if (error) {
|
|
return;
|
|
}
|
|
|
|
return done('Error from flocore-node webserver: ' + res.statusCode);
|
|
|
|
}
|
|
|
|
var resError;
|
|
var resData = '';
|
|
|
|
res.on('error', function(e) {
|
|
resError = e;
|
|
});
|
|
|
|
res.on('data', function(data) {
|
|
resData += data;
|
|
});
|
|
|
|
res.on('end', function() {
|
|
if (error) {
|
|
return;
|
|
}
|
|
var data = JSON.parse(resData);
|
|
console.log(data);
|
|
expect(data.status).to.equal('finished');
|
|
done();
|
|
});
|
|
|
|
});
|
|
request.write('');
|
|
request.end();
|
|
});
|
|
|
|
it('should get peer: /peer', function(done) {
|
|
|
|
var request = http.request('http://localhost:53001/api/peer', function(res) {
|
|
|
|
var error;
|
|
if (res.statusCode !== 200 && res.statusCode !== 201) {
|
|
|
|
if (error) {
|
|
return;
|
|
}
|
|
|
|
return done('Error from flocore-node webserver: ' + res.statusCode);
|
|
|
|
}
|
|
|
|
var resError;
|
|
var resData = '';
|
|
|
|
res.on('error', function(e) {
|
|
resError = e;
|
|
});
|
|
|
|
res.on('data', function(data) {
|
|
resData += data;
|
|
});
|
|
|
|
res.on('end', function() {
|
|
if (error) {
|
|
return;
|
|
}
|
|
var data = JSON.parse(resData);
|
|
console.log(data);
|
|
expect(data.connected).to.be.true;
|
|
done();
|
|
});
|
|
|
|
});
|
|
request.write('');
|
|
request.end();
|
|
});
|
|
|
|
it('should get version: /version', function(done) {
|
|
|
|
var request = http.request('http://localhost:53001/api/version', function(res) {
|
|
|
|
var error;
|
|
if (res.statusCode !== 200 && res.statusCode !== 201) {
|
|
|
|
if (error) {
|
|
return;
|
|
}
|
|
|
|
return done('Error from flocore-node webserver: ' + res.statusCode);
|
|
|
|
}
|
|
|
|
var resError;
|
|
var resData = '';
|
|
|
|
res.on('error', function(e) {
|
|
resError = e;
|
|
});
|
|
|
|
res.on('data', function(data) {
|
|
resData += data;
|
|
});
|
|
|
|
res.on('end', function() {
|
|
if (error) {
|
|
return;
|
|
}
|
|
var data = JSON.parse(resData);
|
|
console.log(data);
|
|
expect(data.version).to.not.be.null;
|
|
done();
|
|
});
|
|
|
|
});
|
|
|
|
request.write('');
|
|
request.end();
|
|
|
|
});
|
|
|
|
it('should estimate fee: /estimateFee', function(done) {
|
|
|
|
var request = http.request('http://localhost:53001/api/utils/estimateFee', function(res) {
|
|
|
|
var error;
|
|
if (res.statusCode !== 200 && res.statusCode !== 201) {
|
|
|
|
if (error) {
|
|
return;
|
|
}
|
|
|
|
return done('Error from flocore-node webserver: ' + res.statusCode);
|
|
|
|
}
|
|
|
|
var resError;
|
|
var resData = '';
|
|
|
|
res.on('error', function(e) {
|
|
resError = e;
|
|
});
|
|
|
|
res.on('data', function(data) {
|
|
resData += data;
|
|
});
|
|
|
|
res.on('end', function() {
|
|
if (error) {
|
|
return;
|
|
}
|
|
var data = JSON.parse(resData);
|
|
console.log(data);
|
|
expect(data['2']).to.not.be.null;
|
|
done();
|
|
});
|
|
|
|
});
|
|
|
|
request.write('');
|
|
request.end();
|
|
|
|
});
|
|
});
|