mirror of https://github.com/BTCPrivate/copay.git
1113 lines
33 KiB
JavaScript
1113 lines
33 KiB
JavaScript
//
|
|
// test/unit/controllers/controllersSpec.js
|
|
//
|
|
|
|
var sinon = require('sinon');
|
|
|
|
// Replace saveAs plugin
|
|
saveAs = function(blob, filename) {
|
|
saveAsLastCall = {
|
|
blob: blob,
|
|
filename: filename
|
|
};
|
|
};
|
|
|
|
describe("Unit: Controllers", function() {
|
|
config.plugins.LocalStorage = true;
|
|
config.plugins.GoogleDrive = null;
|
|
config.plugins.InsightStorage = null;
|
|
config.plugins.EncryptedInsightStorage = null;
|
|
|
|
var anAddr = 'mkfTyEk7tfgV611Z4ESwDDSZwhsZdbMpVy';
|
|
var anAmount = 1000;
|
|
var aComment = 'hola';
|
|
|
|
|
|
|
|
var invalidForm = {
|
|
$invalid: true
|
|
};
|
|
|
|
var scope;
|
|
var server;
|
|
|
|
beforeEach(module('copayApp'));
|
|
beforeEach(module('copayApp.controllers'));
|
|
beforeEach(module(function($provide) {
|
|
$provide.value('request', {
|
|
'get': function(_, cb) {
|
|
cb(null, null, [{
|
|
name: 'USD Dollars',
|
|
code: 'USD',
|
|
rate: 2
|
|
}]);
|
|
}
|
|
});
|
|
}));
|
|
|
|
beforeEach(inject(function($controller, $rootScope) {
|
|
scope = $rootScope.$new();
|
|
$rootScope.safeUnspentCount = 1;
|
|
|
|
//
|
|
// TODO Use the REAL wallet, and stub only networking and DB components!
|
|
//
|
|
|
|
var w = {};
|
|
w.id = 1234;
|
|
w.isComplete = sinon.stub().returns(true);
|
|
w.isShared = sinon.stub().returns(true);
|
|
w.privateKey = {};
|
|
w.settings = {
|
|
unitToSatoshi: 100,
|
|
unitDecimals: 2,
|
|
alternativeName: 'US Dollar',
|
|
alternativeIsoCode: 'USD',
|
|
};
|
|
w.addressBook = {
|
|
'juan': '1',
|
|
};
|
|
w.totalCopayers = 2;
|
|
w.getMyCopayerNickname = sinon.stub().returns('nickname');
|
|
w.getMyCopayerId = sinon.stub().returns('id');
|
|
w.privateKey.toObj = sinon.stub().returns({
|
|
wallet: 'mock'
|
|
});
|
|
w.getSecret = sinon.stub().returns('secret');
|
|
w.getName = sinon.stub().returns('fakeWallet');
|
|
w.exportEncrypted = sinon.stub().returns('1234567');
|
|
w.getTransactionHistory = sinon.stub().yields(null);
|
|
w.getNetworkName = sinon.stub().returns('testnet');
|
|
|
|
w.spend = sinon.stub().yields(null);
|
|
w.sendTxProposal = sinon.stub();
|
|
w.broadcastTx = sinon.stub().yields(null);
|
|
w.requiresMultipleSignatures = sinon.stub().returns(true);
|
|
w.getTxProposals = sinon.stub().returns([1, 2, 3]);
|
|
w.getPendingTxProposals = sinon.stub().returns(
|
|
[{
|
|
isPending: true
|
|
}]
|
|
);
|
|
w.getId = sinon.stub().returns(1234);
|
|
w.on = sinon.stub().yields({
|
|
'e': 'errmsg',
|
|
'loading': false
|
|
});
|
|
w.sizes = sinon.stub().returns({
|
|
tota: 1234
|
|
});
|
|
w.getBalance = sinon.stub().returns(10000);
|
|
w.publicKeyRing = sinon.stub().yields(null);
|
|
w.publicKeyRing.nicknameForCopayer = sinon.stub().returns('nickcopayer');
|
|
w.updateFocusedTimestamp = sinon.stub().returns(1415804323);
|
|
w.getAddressesInfo = sinon.stub().returns([{
|
|
addressStr: "2MxvwvfshZxw4SkkaJZ8NDKLyepa9HLMKtu",
|
|
isChange: false
|
|
}]);
|
|
|
|
|
|
var iden = {};
|
|
iden.getLastFocusedWallet = sinon.stub().returns(null);
|
|
iden.getWallets = sinon.stub().returns([w]);
|
|
iden.getWalletById = sinon.stub().returns(w);
|
|
iden.getName = sinon.stub().returns('name');
|
|
iden.deleteWallet = sinon.stub();
|
|
iden.close = sinon.stub().returns(null);
|
|
|
|
|
|
$rootScope.wallet = w;
|
|
$rootScope.iden = iden;
|
|
}));
|
|
|
|
describe('Create Controller', function() {
|
|
var c;
|
|
beforeEach(inject(function($controller, $rootScope) {
|
|
scope = $rootScope.$new();
|
|
c = $controller('CreateController', {
|
|
$scope: scope,
|
|
});
|
|
}));
|
|
|
|
describe('#getNumber', function() {
|
|
it('should return an array of n undefined elements', function() {
|
|
var n = 5;
|
|
var array = scope.getNumber(n);
|
|
expect(array.length).equal(n);
|
|
});
|
|
});
|
|
describe('#create', function() {
|
|
it('should work with invalid form', function() {
|
|
scope.create(invalidForm);
|
|
});
|
|
});
|
|
});
|
|
|
|
|
|
describe('Create Profile Controller', function() {
|
|
var c, confService, idenService;
|
|
beforeEach(inject(function($controller, $rootScope, configService, identityService) {
|
|
scope = $rootScope.$new();
|
|
confService = configService;
|
|
idenService = identityService;
|
|
c = $controller('CreateProfileController', {
|
|
$scope: scope,
|
|
});
|
|
}));
|
|
|
|
it('should exist', function() {
|
|
should.exist(c);
|
|
});
|
|
|
|
it('#init', function() {
|
|
scope.init();
|
|
});
|
|
|
|
it('#clear', function() {
|
|
scope.clear();
|
|
});
|
|
|
|
it('#saveSettings', function() {
|
|
var old = confService.set;
|
|
confService.set = sinon.stub().returns(null);
|
|
scope.saveSettings();
|
|
confService.set.calledOnce.should.be.true;
|
|
confService.set = old;
|
|
});
|
|
|
|
it('#createProfile', function() {
|
|
var old = scope.saveSettings;
|
|
scope.saveSettings = sinon.stub().returns(null);
|
|
scope.createProfile();
|
|
scope.saveSettings.calledOnce.should.be.true;
|
|
scope.saveSettings = old;
|
|
});
|
|
|
|
it('#_doCreateProfile', function() {
|
|
var old = idenService.create;
|
|
idenService.create = sinon.stub().returns(null);
|
|
scope._doCreateProfile('[email protected]', 'password');
|
|
idenService.create.calledOnce.should.be.true;
|
|
idenService.create = old;
|
|
});
|
|
|
|
it('#createDefaultWallet', function() {
|
|
var old = idenService.createDefaultWallet;
|
|
idenService.createDefaultWallet = sinon.stub().returns(null);
|
|
scope.createDefaultWallet();
|
|
idenService.createDefaultWallet.calledOnce.should.be.true;
|
|
idenService.createDefaultWallet = old;
|
|
});
|
|
|
|
|
|
|
|
});
|
|
|
|
describe('Receive Controller', function() {
|
|
var c;
|
|
var rootScope;
|
|
beforeEach(inject(function($controller, $rootScope) {
|
|
rootScope = $rootScope;
|
|
scope = $rootScope.$new();
|
|
c = $controller('ReceiveController', {
|
|
$scope: scope,
|
|
});
|
|
|
|
|
|
var createW = function(N, conf) {
|
|
|
|
var c = JSON.parse(JSON.stringify(conf || walletConfig));
|
|
if (!N) N = c.totalCopayers;
|
|
|
|
var mainPrivateKey = new copay.PrivateKey({
|
|
networkName: walletConfig.networkName
|
|
});
|
|
var mainCopayerEPK = mainPrivateKey.deriveBIP45Branch().extendedPublicKeyString();
|
|
c.privateKey = mainPrivateKey;
|
|
|
|
c.publicKeyRing = new copay.PublicKeyRing({
|
|
networkName: c.networkName,
|
|
requiredCopayers: Math.min(N, c.requiredCopayers),
|
|
totalCopayers: N,
|
|
});
|
|
c.publicKeyRing.addCopayer(mainCopayerEPK);
|
|
|
|
c.publicKeyRing.getAddressesOrdered = sinon.stub().returns(null);
|
|
|
|
c.txProposals = new copay.TxProposals({
|
|
networkName: c.networkName,
|
|
});
|
|
|
|
c.blockchain = new Blockchain(walletConfig.blockchain);
|
|
|
|
c.network = sinon.stub();
|
|
c.network.setHexNonce = sinon.stub();
|
|
c.network.setHexNonces = sinon.stub();
|
|
c.network.getHexNonce = sinon.stub();
|
|
c.network.getHexNonces = sinon.stub();
|
|
c.network.peerFromCopayer = sinon.stub().returns('xxxx');
|
|
c.network.send = sinon.stub();
|
|
|
|
c.addressBook = {
|
|
'2NFR2kzH9NUdp8vsXTB4wWQtTtzhpKxsyoJ': {
|
|
label: 'John',
|
|
copayerId: '026a55261b7c898fff760ebe14fd22a71892295f3b49e0ca66727bc0a0d7f94d03',
|
|
createdTs: 1403102115,
|
|
hidden: false
|
|
},
|
|
'2MtP8WyiwG7ZdVWM96CVsk2M1N8zyfiVQsY': {
|
|
label: 'Jennifer',
|
|
copayerId: '032991f836543a492bd6d0bb112552bfc7c5f3b7d5388fcbcbf2fbb893b44770d7',
|
|
createdTs: 1403103115,
|
|
hidden: false
|
|
}
|
|
};
|
|
|
|
c.networkName = walletConfig.networkName;
|
|
c.version = '0.0.1';
|
|
|
|
c.generateAddress = sinon.stub().returns({});
|
|
|
|
c.balanceInfo = {};
|
|
|
|
return new Wallet(c);
|
|
};
|
|
|
|
$rootScope.wallet = createW();
|
|
$rootScope.wallet.balanceInfo = {};
|
|
}));
|
|
|
|
it('should exist', function() {
|
|
should.exist(c);
|
|
});
|
|
|
|
it('#init', function() {
|
|
scope.init();
|
|
rootScope.title.should.be.equal('Receive');
|
|
});
|
|
|
|
it('should call setAddressList', function() {
|
|
scope.setAddressList();
|
|
expect(scope.addresses).to.be.empty;
|
|
scope.toggleShowAll();
|
|
scope.setAddressList();
|
|
expect(scope.addresses).to.be.empty;
|
|
});
|
|
|
|
it('#newAddr', function() {
|
|
rootScope.wallet.generateAddress = sinon.stub().returns({});
|
|
scope.newAddr();
|
|
rootScope.wallet.generateAddress.calledOnce.should.be.true;
|
|
});
|
|
});
|
|
|
|
describe('History Controller', function() {
|
|
var ctrl;
|
|
beforeEach(inject(function($controller, $rootScope) {
|
|
|
|
scope = $rootScope.$new();
|
|
scope.wallet = null;
|
|
scope.getTransactions = sinon.stub();
|
|
ctrl = $controller('HistoryController', {
|
|
$scope: scope,
|
|
});
|
|
}));
|
|
|
|
it('should exist', function() {
|
|
should.exist(ctrl);
|
|
});
|
|
|
|
it('should have a HistoryController controller', function() {
|
|
expect(scope.loading).equal(false);
|
|
});
|
|
|
|
// this tests has no sense: getTransaction is async
|
|
it.skip('should return an empty array of tx from insight', function() {
|
|
scope.getTransactions();
|
|
expect(scope.blockchain_txs).to.be.empty;
|
|
});
|
|
});
|
|
|
|
|
|
|
|
describe('Profile Controller', function() {
|
|
var ctrl, bkpService, idenService;
|
|
beforeEach(inject(function($controller, $rootScope, backupService, identityService) {
|
|
scope = $rootScope.$new();
|
|
bkpService = backupService;
|
|
idenService = identityService;
|
|
ctrl = $controller('ProfileController', {
|
|
$scope: scope,
|
|
});
|
|
}));
|
|
|
|
it('should exist', function() {
|
|
should.exist(ctrl);
|
|
});
|
|
|
|
it('#downloadProfileBackup', function() {
|
|
var old = bkpService.profileDownload;
|
|
bkpService.profileDownload = sinon.stub().returns(null);
|
|
scope.downloadProfileBackup();
|
|
bkpService.profileDownload.calledOnce.should.be.true;
|
|
bkpService.profileDownload = old;
|
|
});
|
|
|
|
it('#viewProfileBackup', function() {
|
|
var old = bkpService.profileEncrypted;
|
|
bkpService.profileEncrypted = sinon.stub().returns(null);
|
|
scope.viewProfileBackup();
|
|
//bkpService.profileEncrypted.calledOnce.should.be.true;
|
|
bkpService.profileEncrypted = old;
|
|
});
|
|
|
|
it('#copyProfileBackup', function() {
|
|
var old = bkpService.profileEncrypted;
|
|
bkpService.profileEncrypted = sinon.stub().returns(null);
|
|
|
|
window.cordova = {
|
|
plugins: {
|
|
clipboard: {
|
|
copy: function(e) {
|
|
return e;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
window.plugins = {
|
|
toast: {
|
|
showShortCenter: function(e) {
|
|
return e;
|
|
}
|
|
}
|
|
};
|
|
|
|
scope.copyProfileBackup();
|
|
bkpService.profileEncrypted.calledOnce.should.be.true;
|
|
bkpService.profileEncrypted = old;
|
|
});
|
|
|
|
it('#sendProfileBackup', function() {
|
|
var old = bkpService.profileEncrypted;
|
|
bkpService.profileEncrypted = sinon.stub().returns(null);
|
|
|
|
window.plugin = {
|
|
email: {
|
|
open: function(e) {
|
|
return e;
|
|
}
|
|
}
|
|
};
|
|
|
|
window.plugins = {
|
|
toast: {
|
|
showShortCenter: function(e) {
|
|
return e;
|
|
}
|
|
}
|
|
};
|
|
|
|
scope.sendProfileBackup();
|
|
bkpService.profileEncrypted.calledOnce.should.be.true;
|
|
bkpService.profileEncrypted = old;
|
|
});
|
|
|
|
it('#deleteProfile', function() {
|
|
var old = idenService.deleteProfile;
|
|
idenService.deleteProfile = sinon.stub().returns(null);
|
|
scope.deleteProfile();
|
|
idenService.deleteProfile.calledOnce.should.be.true;
|
|
idenService.deleteProfile = old;
|
|
});
|
|
|
|
|
|
});
|
|
|
|
|
|
|
|
describe('Send Controller', function() {
|
|
var scope, form, sendForm, sendCtrl, rootScope;
|
|
beforeEach(angular.mock.inject(function($compile, $rootScope, $controller, rateService, notification) {
|
|
scope = $rootScope.$new();
|
|
rootScope = $rootScope;
|
|
scope.rateService = rateService;
|
|
var element = angular.element(
|
|
'<form name="form">' +
|
|
'<input type="text" id="newaddress" name="newaddress" ng-disabled="loading" placeholder="Address" ng-model="newaddress" valid-address required>' +
|
|
'<input type="text" id="newlabel" name="newlabel" ng-disabled="loading" placeholder="Label" ng-model="newlabel" required>' +
|
|
'</form>'
|
|
);
|
|
scope.model = {
|
|
newaddress: null,
|
|
newlabel: null,
|
|
_address: null,
|
|
_amount: null
|
|
};
|
|
$compile(element)(scope);
|
|
|
|
var element2 = angular.element(
|
|
'<form name="form2">' +
|
|
'<input type="text" id="address" name="address" ng-model="_address" valid-address required>' +
|
|
'<input type="number" id="amount" name="amount" ng-model="_amount" min="0.00000001" max="10000000000" valid-amount required>' +
|
|
'<input type="number" id="alternative" name="alternative" ng-model="_alternative">' +
|
|
'<textarea id="comment" name="comment" ng-model="commentText" ng-maxlength="100"></textarea>' +
|
|
'</form>'
|
|
);
|
|
$compile(element2)(scope);
|
|
sendCtrl = $controller('SendController', {
|
|
$scope: scope,
|
|
$modal: {},
|
|
});
|
|
scope.init();
|
|
scope.$digest();
|
|
form = scope.form;
|
|
sendForm = scope.form2;
|
|
scope.sendForm = sendForm;
|
|
}));
|
|
|
|
it('should have a SendController controller', function() {
|
|
should.exist(scope.submitForm);
|
|
});
|
|
|
|
it('should have a title', function() {
|
|
expect(scope.title);
|
|
});
|
|
|
|
it('#setError', function() {
|
|
scope.setError('my error');
|
|
expect(scope.error);
|
|
});
|
|
|
|
it('#setFromPayPro', function() {
|
|
var old = rootScope.wallet.fetchPaymentRequest
|
|
rootScope.wallet.fetchPaymentRequest = sinon.stub().returns(null);
|
|
scope.setFromPayPro('newURL');
|
|
rootScope.wallet.fetchPaymentRequest.calledOnce.should.be.true;
|
|
rootScope.wallet.fetchPaymentRequest = old;
|
|
});
|
|
|
|
|
|
|
|
it('should validate address with network', function() {
|
|
form.newaddress.$setViewValue('mkfTyEk7tfgV611Z4ESwDDSZwhsZdbMpVy');
|
|
expect(form.newaddress.$invalid).to.equal(false);
|
|
});
|
|
|
|
it('should not validate address with other network', function() {
|
|
form.newaddress.$setViewValue('1JqniWpWNA6Yvdivg3y9izLidETnurxRQm');
|
|
expect(form.newaddress.$invalid).to.equal(true);
|
|
});
|
|
|
|
it('should not validate random address', function() {
|
|
form.newaddress.$setViewValue('thisisaninvalidaddress');
|
|
expect(form.newaddress.$invalid).to.equal(true);
|
|
});
|
|
|
|
it('should validate label', function() {
|
|
form.newlabel.$setViewValue('John');
|
|
expect(form.newlabel.$invalid).to.equal(false);
|
|
});
|
|
|
|
it('should not validate label', function() {
|
|
expect(form.newlabel.$invalid).to.equal(true);
|
|
});
|
|
|
|
it('should create a transaction proposal with given values', inject(function($timeout) {
|
|
sendForm.address.$setViewValue(anAddr);
|
|
sendForm.amount.$setViewValue(anAmount);
|
|
sendForm.comment.$setViewValue(aComment);
|
|
|
|
var w = scope.wallet;
|
|
scope.submitForm(sendForm);
|
|
|
|
$timeout.flush();
|
|
sinon.assert.callCount(w.spend, 1);
|
|
sinon.assert.callCount(w.broadcastTx, 0);
|
|
var spendArgs = w.spend.getCall(0).args[0];
|
|
spendArgs.toAddress.should.equal(anAddr);
|
|
spendArgs.amountSat.should.equal(anAmount * scope.wallet.settings.unitToSatoshi);
|
|
spendArgs.comment.should.equal(aComment);
|
|
}));
|
|
|
|
|
|
it('should handle big values in 100 BTC', inject(function($timeout) {
|
|
var old = scope.wallet.settings.unitToSatoshi;
|
|
scope.wallet.settings.unitToSatoshi = 100000000;
|
|
sendForm.address.$setViewValue(anAddr);
|
|
sendForm.amount.$setViewValue(100);
|
|
sendForm.address.$setViewValue(anAddr);
|
|
|
|
scope.updateTxs = sinon.spy();
|
|
scope.submitForm(sendForm);
|
|
var w = scope.wallet;
|
|
$timeout.flush();
|
|
w.spend.getCall(0).args[0].amountSat.should.equal(100 * scope.wallet.settings.unitToSatoshi);
|
|
scope.wallet.settings.unitToSatoshi = old;
|
|
}));
|
|
|
|
|
|
it('should handle big values in 5000 BTC', inject(function($rootScope, $timeout) {
|
|
var w = scope.wallet;
|
|
w.requiresMultipleSignatures = sinon.stub().returns(true);
|
|
|
|
|
|
var old = $rootScope.wallet.settings.unitToSatoshi;
|
|
$rootScope.wallet.settings.unitToSatoshi = 100000000;
|
|
sendForm.address.$setViewValue(anAddr);
|
|
sendForm.amount.$setViewValue(5000);
|
|
scope.submitForm(sendForm);
|
|
$timeout.flush();
|
|
|
|
w.spend.getCall(0).args[0].amountSat.should.equal(5000 * $rootScope.wallet.settings.unitToSatoshi);
|
|
$rootScope.wallet.settings.unitToSatoshi = old;
|
|
}));
|
|
|
|
it('should convert bits amount to fiat', function(done) {
|
|
scope.rateService.whenAvailable(function() {
|
|
sendForm.amount.$setViewValue(1e6);
|
|
scope.$digest();
|
|
expect(scope._amount).to.equal(1e6);
|
|
expect(scope.__alternative).to.equal(2);
|
|
done();
|
|
});
|
|
});
|
|
it('should convert fiat to bits amount', function(done) {
|
|
scope.rateService.whenAvailable(function() {
|
|
sendForm.alternative.$setViewValue(2);
|
|
scope.$digest();
|
|
expect(scope.__alternative).to.equal(2);
|
|
expect(scope._amount).to.equal(1e6);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('receive from uri using bits', inject(function() {
|
|
sendForm.address.$setViewValue('bitcoin:mxf5psDyA8EQVzb2MZ7MkDWiXuAuWWCRMB?amount=1.018085');
|
|
expect(sendForm.amount.$modelValue).to.equal(1018085);
|
|
sendForm.address.$setViewValue('bitcoin:mxf5psDyA8EQVzb2MZ7MkDWiXuAuWWCRMB?amount=1.01808500');
|
|
expect(sendForm.amount.$modelValue).to.equal(1018085);
|
|
sendForm.address.$setViewValue('bitcoin:mxf5psDyA8EQVzb2MZ7MkDWiXuAuWWCRMB?amount=0.29133585');
|
|
expect(sendForm.amount.$modelValue).to.equal(291335.85);
|
|
}));
|
|
|
|
it('receive from uri using BTC', inject(function($rootScope) {
|
|
var old = $rootScope.wallet.settings.unitToSatoshi;
|
|
var old_decimals = $rootScope.wallet.settings.unitDecimals;
|
|
$rootScope.wallet.settings.unitToSatoshi = 100000000;
|
|
$rootScope.wallet.settings.unitDecimals = 8;
|
|
sendForm.address.$setViewValue('bitcoin:mxf5psDyA8EQVzb2MZ7MkDWiXuAuWWCRMB?amount=1.018085');
|
|
expect(sendForm.amount.$modelValue).to.equal(1.018085);
|
|
sendForm.address.$setViewValue('bitcoin:mxf5psDyA8EQVzb2MZ7MkDWiXuAuWWCRMB?amount=1.01808500');
|
|
expect(sendForm.amount.$modelValue).to.equal(1.018085);
|
|
sendForm.address.$setViewValue('bitcoin:mxf5psDyA8EQVzb2MZ7MkDWiXuAuWWCRMB?amount=0.29133585');
|
|
expect(sendForm.amount.$modelValue).to.equal(0.29133585);
|
|
sendForm.address.$setViewValue('bitcoin:mxf5psDyA8EQVzb2MZ7MkDWiXuAuWWCRMB?amount=0.1');
|
|
expect(sendForm.amount.$modelValue).to.equal(0.1);
|
|
$rootScope.wallet.settings.unitToSatoshi = old;
|
|
$rootScope.wallet.settings.unitDecimals = old_decimals;
|
|
}));
|
|
});
|
|
|
|
describe("Unit: Version Controller", function() {
|
|
var scope, $httpBackendOut;
|
|
var GH = 'https://api.github.com/repos/bitpay/copay/tags';
|
|
beforeEach(inject(function($controller, $injector) {
|
|
$httpBackend = $injector.get('$httpBackend');
|
|
$httpBackend.when('GET', GH)
|
|
.respond([{
|
|
name: "v100.1.6",
|
|
zipball_url: "https://api.github.com/repos/bitpay/copay/zipball/v0.0.6",
|
|
tarball_url: "https://api.github.com/repos/bitpay/copay/tarball/v0.0.6",
|
|
commit: {
|
|
sha: "ead7352bf2eca705de58d8b2f46650691f2bc2c7",
|
|
url: "https://api.github.com/repos/bitpay/copay/commits/ead7352bf2eca705de58d8b2f46650691f2bc2c7"
|
|
}
|
|
}]);
|
|
}));
|
|
|
|
var rootScope;
|
|
beforeEach(inject(function($controller, $rootScope) {
|
|
rootScope = $rootScope;
|
|
scope = $rootScope.$new();
|
|
headerCtrl = $controller('VersionController', {
|
|
$scope: scope,
|
|
});
|
|
}));
|
|
|
|
afterEach(function() {
|
|
$httpBackend.verifyNoOutstandingExpectation();
|
|
$httpBackend.verifyNoOutstandingRequest();
|
|
});
|
|
|
|
|
|
|
|
it('should hit github for version', function() {
|
|
$httpBackend.expectGET(GH);
|
|
scope.$apply();
|
|
$httpBackend.flush();
|
|
});
|
|
|
|
it('should check version ', inject(function($injector) {
|
|
notification = $injector.get('notification');
|
|
var spy = sinon.spy(notification, 'version');
|
|
$httpBackend.expectGET(GH);
|
|
scope.$apply();
|
|
$httpBackend.flush();
|
|
spy.calledOnce.should.equal(true);
|
|
}));
|
|
|
|
it('should check blockChainStatus', function() {
|
|
$httpBackend.expectGET(GH);
|
|
$httpBackend.flush();
|
|
rootScope.insightError = 1;
|
|
scope.$apply();
|
|
expect(rootScope.insightError).equal(1);
|
|
scope.$apply();
|
|
expect(rootScope.insightError).equal(1);
|
|
scope.$apply();
|
|
});
|
|
});
|
|
|
|
describe("Unit: Sidebar Controller", function() {
|
|
beforeEach(inject(function($controller, $rootScope) {
|
|
rootScope = $rootScope;
|
|
scope = $rootScope.$new();
|
|
headerCtrl = $controller('SidebarController', {
|
|
$scope: scope,
|
|
});
|
|
}));
|
|
|
|
it('should call sign out', function() {
|
|
scope.signout();
|
|
rootScope.iden.close.calledOnce.should.be.true;
|
|
});
|
|
});
|
|
|
|
describe("Head Controller", function() {
|
|
var scope, ctrl, rootScope, idenService, balService;
|
|
beforeEach(inject(function($controller, $rootScope, identityService, balanceService) {
|
|
rootScope = $rootScope;
|
|
idenService = identityService;
|
|
balService = balanceService;
|
|
scope = $rootScope.$new();
|
|
ctrl = $controller('HeadController', {
|
|
$scope: scope,
|
|
});
|
|
}));
|
|
|
|
it('should exist', function() {
|
|
should.exist(ctrl);
|
|
});
|
|
|
|
it('should call sign out', function() {
|
|
var old = idenService.signout;
|
|
idenService.signout = sinon.stub().returns(null);
|
|
scope.signout();
|
|
idenService.signout.calledOnce.should.be.true;
|
|
idenService.signout = old;
|
|
});
|
|
|
|
it('should call refresh', function() {
|
|
var old = rootScope.wallet.sendWalletReady;
|
|
rootScope.wallet.sendWalletReady = sinon.stub().returns(null);
|
|
balService.clearBalanceCache = sinon.stub().returns(null);
|
|
scope.refresh();
|
|
rootScope.wallet.sendWalletReady.calledOnce.should.be.true;
|
|
rootScope.wallet.sendWalletReady = old;
|
|
});
|
|
|
|
});
|
|
|
|
describe('Send Controller', function() {
|
|
var sendCtrl, form;
|
|
beforeEach(inject(function($compile, $rootScope, $controller) {
|
|
scope = $rootScope.$new();
|
|
$rootScope.availableBalance = 123456;
|
|
|
|
var element = angular.element(
|
|
'<form name="form">' +
|
|
'<input type="number" id="amount" name="amount" placeholder="Amount" ng-model="amount" min="0.0001" max="10000000" enough-amount required>' +
|
|
'</form>'
|
|
);
|
|
scope.model = {
|
|
amount: null
|
|
};
|
|
$compile(element)(scope);
|
|
scope.$digest();
|
|
form = scope.form;
|
|
|
|
sendCtrl = $controller('SendController', {
|
|
$scope: scope,
|
|
$modal: {},
|
|
});
|
|
}));
|
|
|
|
it('should have a SendController', function() {
|
|
expect(scope.isMobile).not.to.equal(null);
|
|
});
|
|
it('should autotop balance correctly', function() {
|
|
scope.setTopAmount(form);
|
|
form.amount.$setViewValue(123356);
|
|
expect(scope.amount).to.equal(123356);
|
|
expect(form.amount.$invalid).to.equal(false);
|
|
expect(form.amount.$pristine).to.equal(false);
|
|
});
|
|
});
|
|
|
|
describe('Import Controller', function() {
|
|
var ctrl;
|
|
beforeEach(inject(function($controller, $rootScope) {
|
|
scope = $rootScope.$new();
|
|
ctrl = $controller('ImportController', {
|
|
$scope: scope,
|
|
});
|
|
}));
|
|
|
|
it('should exist', function() {
|
|
should.exist(ctrl);
|
|
});
|
|
it('import status', function() {
|
|
expect(scope.importStatus).equal('Importing wallet - Reading backup...');
|
|
});
|
|
});
|
|
|
|
// TODO: fix this test
|
|
describe.skip('Home Controller', function() {
|
|
var ctrl;
|
|
beforeEach(inject(function($controller, $rootScope) {
|
|
scope = $rootScope.$new();
|
|
ctrl = $controller('HomeController', {
|
|
$scope: scope,
|
|
});
|
|
}));
|
|
|
|
it('should exist', function() {
|
|
should.exist(ctrl);
|
|
});
|
|
describe('#open', function() {
|
|
it('should work with invalid form', function() {
|
|
scope.open(invalidForm);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('SignOut Controller', function() {
|
|
var ctrl;
|
|
beforeEach(inject(function($controller, $rootScope) {
|
|
scope = $rootScope.$new();
|
|
ctrl = $controller('signOutController', {
|
|
$scope: scope,
|
|
});
|
|
}));
|
|
|
|
it('should exist', function() {
|
|
should.exist(ctrl);
|
|
});
|
|
});
|
|
|
|
describe('Settings Controller', function() {
|
|
var what;
|
|
beforeEach(inject(function($controller, $rootScope) {
|
|
scope = $rootScope.$new();
|
|
what = $controller('SettingsController', {
|
|
$scope: scope,
|
|
});
|
|
}));
|
|
|
|
it('should exist', function() {
|
|
should.exist(what);
|
|
});
|
|
});
|
|
|
|
describe('Copayers Controller', function() {
|
|
var saveDownload = null;
|
|
var ctrl, rootScope, idenService;
|
|
beforeEach(inject(function($controller, $rootScope, identityService) {
|
|
scope = $rootScope.$new();
|
|
rootScope = $rootScope;
|
|
idenService = identityService;
|
|
ctrl = $controller('CopayersController', {
|
|
$scope: scope,
|
|
$modal: {},
|
|
});
|
|
}));
|
|
|
|
it('should exist', function() {
|
|
should.exist(ctrl);
|
|
});
|
|
|
|
it('#init', function() {
|
|
var old = scope.updateList;
|
|
scope.updateList = sinon.stub().returns(null);
|
|
scope.init();
|
|
scope.updateList.callCount.should.be.equal(3); //why 3 ??????
|
|
scope.updateList = old;
|
|
});
|
|
|
|
it('#updateList', function() {
|
|
var old = rootScope.wallet.getRegisteredPeerIds;
|
|
rootScope.wallet.getRegisteredPeerIds = sinon.stub().returns(null);
|
|
rootScope.wallet.removeListener = sinon.stub().returns(null);
|
|
scope.updateList();
|
|
rootScope.wallet.getRegisteredPeerIds.callCount.should.be.equal(1);
|
|
rootScope.wallet.getRegisteredPeerIds = old;
|
|
});
|
|
|
|
it('#deleteWallet', inject(function($timeout) {
|
|
var old = idenService.deleteWallet;
|
|
idenService.deleteWallet = sinon.stub().returns(null);
|
|
scope.deleteWallet();
|
|
$timeout.flush();
|
|
idenService.deleteWallet.callCount.should.be.equal(1);
|
|
idenService.deleteWallet = old;
|
|
}));
|
|
|
|
});
|
|
|
|
describe('Join Controller', function() {
|
|
var ctrl;
|
|
beforeEach(inject(function($controller, $rootScope) {
|
|
scope = $rootScope.$new();
|
|
ctrl = $controller('JoinController', {
|
|
$scope: scope,
|
|
});
|
|
}));
|
|
|
|
it('should exist', function() {
|
|
should.exist(ctrl);
|
|
});
|
|
describe('#join', function() {
|
|
it('should work with invalid form', function() {
|
|
scope.join(invalidForm);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('paymentUriController Controller', function() {
|
|
var what;
|
|
beforeEach(inject(function($controller, $rootScope, $location) {
|
|
scope = $rootScope.$new();
|
|
var routeParams = {
|
|
data: 'bitcoin:19mP9FKrXqL46Si58pHdhGKow88SUPy1V8'
|
|
};
|
|
var query = {
|
|
amount: 0.1,
|
|
message: "a bitcoin donation"
|
|
};
|
|
what = $controller('paymentUriController', {
|
|
$scope: scope,
|
|
$routeParams: routeParams,
|
|
$location: {
|
|
search: function() {
|
|
return query;
|
|
}
|
|
}
|
|
});
|
|
}));
|
|
|
|
it('should exist', function() {
|
|
should.exist(what);
|
|
});
|
|
|
|
it('should parse url correctly', function() {
|
|
should.exist(what);
|
|
should.exist(scope.pendingPayment);
|
|
scope.pendingPayment.should.equal('bitcoin:19mP9FKrXqL46Si58pHdhGKow88SUPy1V8?amount=0.1&message=a bitcoin donation');
|
|
});
|
|
});
|
|
|
|
describe('Warning Controller', function() {
|
|
var ctrl, idenService;
|
|
beforeEach(inject(function($controller, $rootScope, identityService) {
|
|
scope = $rootScope.$new();
|
|
idenService = identityService;
|
|
ctrl = $controller('WarningController', {
|
|
$scope: scope,
|
|
});
|
|
}));
|
|
|
|
it('should exist', function() {
|
|
should.exist(ctrl);
|
|
});
|
|
|
|
it('#signout', function() {
|
|
var old = idenService.signout;
|
|
idenService.signout = sinon.stub().returns(null);
|
|
scope.signout();
|
|
idenService.signout.calledOnce.should.be.true;
|
|
idenService.signout = old;
|
|
});
|
|
|
|
});
|
|
|
|
describe('More Controller', function() {
|
|
var ctrl, modalCtrl, rootScope, idenService, bkpService;
|
|
beforeEach(inject(function($controller, $rootScope, backupService, identityService) {
|
|
scope = $rootScope.$new();
|
|
rootScope = $rootScope;
|
|
idenService = identityService;
|
|
bkpService = backupService;
|
|
ctrl = $controller('MoreController', {
|
|
$scope: scope
|
|
});
|
|
saveAsLastCall = null;
|
|
|
|
}));
|
|
|
|
it('Backup Wallet controller #download', function() {
|
|
var w = scope.wallet;
|
|
expect(saveAsLastCall).equal(null);
|
|
scope.downloadWalletBackup();
|
|
|
|
expect(saveAsLastCall.blob.size).equal(7);
|
|
expect(saveAsLastCall.blob.type).equal('text/plain;charset=utf-8');
|
|
});
|
|
|
|
it('Backup Wallet controller should name backup correctly for multiple copayers', function() {
|
|
var w = scope.wallet;
|
|
expect(saveAsLastCall).equal(null);
|
|
scope.downloadWalletBackup();
|
|
expect(saveAsLastCall.filename).equal('nickname-fakeWallet-keybackup.json.aes');
|
|
});
|
|
|
|
it('Backup Wallet controller should name backup correctly for 1-1 wallet', function() {
|
|
var w = scope.wallet;
|
|
expect(saveAsLastCall).equal(null);
|
|
scope.wallet.totalCopayers = 1;
|
|
scope.downloadWalletBackup();
|
|
expect(saveAsLastCall.filename).equal('fakeWallet-keybackup.json.aes');
|
|
});
|
|
|
|
it('Delete a wallet', inject(function($timeout) {
|
|
var w = scope.wallet;
|
|
|
|
scope.deleteWallet();
|
|
$timeout.flush();
|
|
scope.$digest();
|
|
scope.iden.deleteWallet.calledOnce.should.equal(true);
|
|
scope.iden.deleteWallet.getCall(0).args[0].should.equal(w.getId());
|
|
}));
|
|
|
|
it('#save', function() {
|
|
var old = rootScope.wallet.changeSettings;
|
|
rootScope.wallet.changeSettings = sinon.stub().returns(null);
|
|
scope.selectedUnit = {};
|
|
scope.save();
|
|
rootScope.wallet.changeSettings.calledOnce.should.equal.true;
|
|
rootScope.wallet.changeSettings = old;
|
|
});
|
|
|
|
it('#purge checking balance', function() {
|
|
var old = rootScope.wallet.purgeTxProposals;
|
|
rootScope.wallet.purgeTxProposals = sinon.stub().returns(true);
|
|
scope.purge();
|
|
rootScope.wallet.purgeTxProposals.calledOnce.should.equal.true;
|
|
rootScope.wallet.purgeTxProposals = old;
|
|
});
|
|
|
|
it('#purge without checking balance', function() {
|
|
var old = rootScope.wallet.purgeTxProposals;
|
|
rootScope.wallet.purgeTxProposals = sinon.stub().returns(false);
|
|
scope.purge();
|
|
rootScope.wallet.purgeTxProposals.calledOnce.should.equal.true;
|
|
rootScope.wallet.purgeTxProposals = old;
|
|
});
|
|
|
|
it('#updateIndexes', function() {
|
|
var old = rootScope.wallet.purgeTxProposals;
|
|
rootScope.wallet.updateIndexes = sinon.stub().yields();
|
|
scope.updateIndexes();
|
|
rootScope.wallet.updateIndexes.calledOnce.should.equal.true;
|
|
rootScope.wallet.updateIndexes = old;
|
|
});
|
|
|
|
it('#updateIndexes return error', function() {
|
|
var old = rootScope.wallet.purgeTxProposals;
|
|
rootScope.wallet.updateIndexes = sinon.stub().yields('error');
|
|
scope.updateIndexes();
|
|
rootScope.wallet.updateIndexes.calledOnce.should.equal.true;
|
|
rootScope.wallet.updateIndexes = old;
|
|
});
|
|
|
|
it('#deleteWallet', inject(function($timeout) {
|
|
var old = idenService.deleteWallet;
|
|
idenService.deleteWallet = sinon.stub().yields(null);
|
|
scope.deleteWallet();
|
|
$timeout.flush();
|
|
idenService.deleteWallet.calledOnce.should.equal.true;
|
|
scope.loading.should.be.false;
|
|
idenService.deleteWallet = old;
|
|
}));
|
|
|
|
it('#deleteWallet with error', inject(function($timeout) {
|
|
var old = idenService.deleteWallet;
|
|
idenService.deleteWallet = sinon.stub().yields('error');
|
|
scope.deleteWallet();
|
|
$timeout.flush();
|
|
idenService.deleteWallet.calledOnce.should.equal.true;
|
|
scope.error.should.be.equal('error');
|
|
idenService.deleteWallet = old;
|
|
}));
|
|
|
|
it('#viewWalletBackup', function() {
|
|
var old = bkpService.walletEncrypted;
|
|
bkpService.walletEncrypted = sinon.stub().returns('backup0001');
|
|
scope.viewWalletBackup();
|
|
bkpService.walletEncrypted.calledOnce.should.equal.true;
|
|
bkpService.walletEncrypted = old;
|
|
});
|
|
|
|
it('#copyWalletBackup', function() {
|
|
var old = bkpService.walletEncrypted;
|
|
bkpService.walletEncrypted = sinon.stub().returns('backup0001');
|
|
window.cordova = {
|
|
plugins: {
|
|
clipboard: {
|
|
copy: function(e) {
|
|
return e;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
window.plugins = {
|
|
toast: {
|
|
showShortCenter: function(e) {
|
|
return e;
|
|
}
|
|
}
|
|
};
|
|
scope.copyWalletBackup();
|
|
bkpService.walletEncrypted.calledOnce.should.equal.true;
|
|
bkpService.walletEncrypted = old;
|
|
});
|
|
|
|
it('#sendWalletBackup', function() {
|
|
var old = bkpService.walletEncrypted;
|
|
bkpService.walletEncrypted = sinon.stub().returns('backup0001');
|
|
|
|
window.plugins = {
|
|
toast: {
|
|
showShortCenter: function(e) {
|
|
return e;
|
|
}
|
|
}
|
|
};
|
|
|
|
window.plugin = {
|
|
email: {
|
|
open: function(e) {
|
|
return e;
|
|
}
|
|
}
|
|
};
|
|
scope.sendWalletBackup();
|
|
bkpService.walletEncrypted.calledOnce.should.equal.true;
|
|
bkpService.walletEncrypted = old;
|
|
});
|
|
|
|
});
|
|
|
|
});
|