mangopay4-nodejs-sdk 1.64.0

package/test/main.js

@@ -0,0 +1,10 @@
+var Promise = require('promise');
+var expect = require('chai').expect;
+var mangopay = require('../index');
+
+var api = global.api = new mangopay({
+    clientId: 'sdk-unit-tests',
+    clientApiKey: 'cqFfFrWfCcb7UadHNxx2C9Lo6Djw8ZduLi7J9USTmu8bhxxpju'
+});
+
+module.exports = api;

package/test/mocha.opts

@@ -0,0 +1,3 @@
+--recursive
+--timeout 15000
+--ui bdd

package/test/services/BankAccounts.js

@@ -0,0 +1,46 @@
+var expect = require('chai').expect;
+var helpers = require('../helpers');
+var UserNatural = require('../../lib/models/UserNatural');
+var BankAccount = require('../../lib/models/BankAccount');
+var BankAccountDetailsIBAN = require('../../lib/models/BankAccountDetailsIBAN');
+var api = require('../main');
+
+describe('Bank Accounts', function () {
+    var john = new UserNatural(helpers.data.getUserNatural());
+    var bankAccount;
+
+    before(function (done) {
+        api.Users.create(john).then(function (data, response) {
+            john = data;
+
+            var account = new BankAccount({
+                OwnerName: john.FirstName + ' ' + john.LastName,
+                OwnerAddress: john.Address,
+                Details: new BankAccountDetailsIBAN({
+                    IBAN: 'FR7630004000031234567890143',
+                    BIC: 'BNPAFRPP'
+                })
+            });
+            api.Users.createBankAccount(john.Id, account).then(function (account) {
+                bankAccount = account;
+                done();
+            });
+        })
+    });
+
+    describe('Get Transactions for an Account', function () {
+        var getTransactions;
+
+        before(function (done) {
+            api.BankAccounts.getTransactions(bankAccount.Id, function (data, response) {
+                getTransactions = data;
+                done();
+            });
+        });
+
+        it('should be retrieved', function () {
+            expect(getTransactions).not.to.be.undefined;
+            expect(getTransactions).to.be.an('array');
+        });
+    });
+});

package/test/services/BankingAliases.js

@@ -0,0 +1,89 @@
+var expect = require('chai').expect;
+var helpers = require('../helpers');
+var api = require('../main');
+
+describe('Banking Aliases', function() {
+    var john = helpers.data.getUserNatural();
+    var bankingAlias;
+
+    before(function(done) {
+        api.Users.create(john).then(function(){
+            wallet = {
+                Owners: [john.Id],
+                Currency: 'EUR',
+                Description: 'WALLET IN EUR'
+            };
+            api.Wallets.create(wallet).then(function(){
+                bankingAlias = new api.models.BankingAliasIBAN({
+                    CreditedUserId: john.Id,
+                    WalletId: wallet.Id,
+                    OwnerName: john.FirstName,
+                    Country: 'LU'
+                });
+                api.BankingAliases.create(bankingAlias).then(function(data){
+                    bankingAlias = data;
+                    done();
+                });
+            });
+        });
+    });
+
+    it('should exist after creating it', function () {
+        expect(bankingAlias.Id).to.exist;
+        expect(bankingAlias.VirtualAccountPurpose).to.exist;
+    });
+
+    describe('Getting created banking alias', function () {
+        var getBankingAlias;
+
+        before(function(done){
+            api.BankingAliases.get(bankingAlias.Id).then(function(data){
+                getBankingAlias = data;
+                done();
+            });
+        });
+
+        it('should be correctly fetched', function () {
+            expect(bankingAlias.Id).to.equal(getBankingAlias.Id);
+            expect(bankingAlias.WalletId).to.equal(getBankingAlias.WalletId);
+            expect(bankingAlias.OwnerName).to.equal(getBankingAlias.OwnerName);
+            expect(bankingAlias.CreditedUserId).to.equal(getBankingAlias.CreditedUserId);
+            expect(bankingAlias.CreationDate).to.equal(getBankingAlias.CreationDate);
+        });
+    });
+
+    describe('Getting created banking aliases', function () {
+        var getBankingAlias;
+
+        before(function(done){
+            api.BankingAliases.getAll(bankingAlias.WalletId).then(function(data){
+                getBankingAlias = data;
+                done();
+            });
+        });
+
+        it('should be ok', function () {
+            expect(getBankingAlias).to.not.be.null;
+            expect(getBankingAlias.length).to.equal(1);
+        });
+    });
+
+    describe('Deactivate the Bank Alias', function () {
+        var deactivatedBankingAlias;
+
+        before(function(done){
+            api.BankingAliases.deactivate(bankingAlias.Id).then(function(data){
+                api.BankingAliases.get(bankingAlias.Id).then(function(data){
+                    deactivatedBankingAlias = data;
+                    done();
+                });
+            });
+
+        });
+
+        it('should have the right activated flag', function () {
+            expect(deactivatedBankingAlias.Id).to.equal(bankingAlias.Id);
+            expect(deactivatedBankingAlias.Active).to.equal(false);
+        });
+    });
+});

package/test/services/CardPreAuthorizations.js

@@ -0,0 +1,70 @@
+var expect = require('chai').expect;
+var api = require('../main');
+var helpers = require('../helpers');
+
+describe('Card PreAuthorizations', function() {
+    var john = helpers.data.getUserNatural();
+    var preAuthorization;
+
+    before(function(done){
+        api.Users.create(john, function(){
+            done();
+        });
+    });
+
+    describe('Create', function() {
+        before(function(done){
+            helpers.getUserCardPreAuthorization(api, john, function(data, response){
+                preAuthorization = data;
+                done();
+            });
+        });
+
+        it('should be created', function(){
+            expect(preAuthorization.Id).to.exist;
+            expect(preAuthorization.Status).to.equal('SUCCEEDED');
+            expect(preAuthorization.PaymentStatus).to.equal('WAITING');
+            expect(preAuthorization.ExecutionType).to.equal('DIRECT');
+            expect(preAuthorization.PayInId).to.be.null;
+            expect(preAuthorization.RemainingFunds).to.exist;
+            expect(preAuthorization.CardInfo).to.not.be.null;
+        });
+    });
+
+    describe('Get', function() {
+        var getPreAuthorization;
+
+        before(function(done){
+            api.CardPreAuthorizations.get(preAuthorization.Id, function(data, response){
+                getPreAuthorization = data;
+                done();
+            });
+        });
+
+        it('should be fetched', function(){
+            expect(getPreAuthorization.Id).to.equal(preAuthorization.Id);
+            expect(getPreAuthorization.ResultCode).to.equal('000000');
+            expect(getPreAuthorization.RemainingFunds).to.exist;
+        });
+    });
+
+    describe('Update', function() {
+        var updatedPreAuthorization;
+
+        before(function(done){
+            preAuthorization.PaymentStatus = 'CANCELED';
+
+            api.CardPreAuthorizations.update(preAuthorization, function(data, response){
+                updatedPreAuthorization = data;
+                done();
+            });
+        });
+
+        it('should be updated', function(){
+            expect(updatedPreAuthorization.Status).to.equal('SUCCEEDED');
+            expect(updatedPreAuthorization.PaymentStatus).to.equal('CANCELED');
+            expect(updatedPreAuthorization.SecurityInfo.AVSResult).to.equal('NO_CHECK');
+            expect(updatedPreAuthorization.RemainingFunds).to.exist;
+        });
+    });
+});

package/test/services/CardRegistrations.js

@@ -0,0 +1,239 @@
+var _ = require('underscore');
+var expect = require('chai').expect;
+var helpers = require('../helpers');
+var api = require('../main');
+
+describe('Card Registrations', function () {
+    var cardRegistration;
+    var john = helpers.data.getUserNatural();
+
+    before(function(done){
+        api.Users.create(john, function(){
+            done();
+        });
+    });
+
+    describe('Create', function () {
+        before(function (done) {
+            cardRegistration = {
+                UserId: john.Id,
+                Currency: 'EUR'
+            };
+            api.CardRegistrations.create(cardRegistration, function(data, response){
+                done();
+            });
+        });
+
+        it('should be created', function () {
+            expect(cardRegistration.Id).not.to.be.undefined;
+            expect(cardRegistration.AccessKey).not.to.be.undefined;
+            expect(cardRegistration.PreregistrationData).not.to.be.undefined;
+            expect(cardRegistration.CardRegistrationURL).not.to.be.undefined;
+            expect(cardRegistration.Status).to.equal('CREATED');
+            expect(cardRegistration.Currency).to.equal('EUR');
+            expect(cardRegistration.UserId).to.equal(john.Id);
+        });
+    });
+
+    describe('Get', function () {
+        var cardRegistrationGet;
+
+        before(function (done) {
+            api.CardRegistrations.get(cardRegistration.Id, function(data, response){
+                cardRegistrationGet = data;
+                done();
+            });
+        });
+
+        it('should be retrieved', function () {
+            expect(cardRegistrationGet.Id).to.equal(cardRegistration.Id);
+            expect(cardRegistrationGet.PreregistrationData).to.equal(cardRegistration.PreregistrationData);
+        });
+    });
+
+    describe('Update', function () {
+        var updatedCardRegistration, newRegistrationData;
+
+        before(function (done) {
+            var options = {
+                data: {
+                    data: cardRegistration.PreregistrationData,
+                    accessKeyRef: cardRegistration.AccessKey,
+                    cardNumber: '4970107111111119',
+                    cardExpirationDate: '1229',
+                    cardCvx: '123'
+                },
+                url: cardRegistration.CardRegistrationURL,
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded'
+                }
+            };
+
+            api.method('post', function (data, response) {
+                cardRegistration.RegistrationData = Buffer.from(data).toString();
+                newRegistrationData = cardRegistration.RegistrationData;
+                api.CardRegistrations.update(cardRegistration).then(function(data){
+                    updatedCardRegistration = data;
+                    done();
+                });
+            }, options);
+        });
+
+        it('should be updated', function () {
+            console.log(JSON.stringify(updatedCardRegistration));
+            expect(updatedCardRegistration.RegistrationData).to.equal(newRegistrationData);
+            expect(updatedCardRegistration.Status).to.equal('VALIDATED');
+            expect(updatedCardRegistration.ResultCode).to.equal('000000');
+            expect(updatedCardRegistration.CardId).to.not.be.undefined;
+        });
+    });
+
+    describe('Update Error', function () {
+        var newCardRegistration;
+        before(function (done) {
+            newCardRegistration = {
+                UserId: john.Id,
+                Currency: 'EUR'
+            };
+
+            api.CardRegistrations.create(newCardRegistration, function(data, response){
+                newCardRegistration.RegistrationData = 'Wrong-data';
+                api.CardRegistrations.update(newCardRegistration, function(data, response){
+                    done();
+                });
+            });
+        });
+
+        it('should fail', function () {
+            expect(newCardRegistration.ResultCode).not.to.be.undefined;
+            expect(newCardRegistration.ResultMessage).not.to.be.undefined;
+            expect(newCardRegistration.Status).to.equal('ERROR');
+        });
+    });
+
+    describe('Cards', function () {
+        var card;
+        var validatedCard;
+        var fetchedCardValidation;
+        before(function(done) {
+            api.Cards.get(cardRegistration.CardId, function(data, response){
+                card = data;
+                done();
+            });
+        });
+
+        describe('Validate Card', function () {
+            before(function(done) {
+                var cardValidation = {
+                    AuthorId: cardRegistration.UserId,
+                    SecureModeReturnURL: "http://example.com",
+                    IpAddress: "2001:0620:0000:0000:0211:24FF:FE80:C12C",
+                    BrowserInfo: {
+                        AcceptHeader: "text/html, application/xhtml+xml, application/xml;q=0.9, /;q=0.8",
+                        ColorDepth: 4,
+                        JavaEnabled: true,
+                        JavascriptEnabled: true,
+                        Language: 'FR-FR',
+                        ScreenHeight: 1800,
+                        ScreenWidth: 400,
+                        TimeZoneOffset: "+60",
+                        UserAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 13_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148"
+                    }
+                };
+
+                api.Cards.validate(cardRegistration.CardId, cardValidation, function (data) {
+                    validatedCard = data;
+                    done();
+                });
+            });
+
+            it('should be validated', function () {
+                expect(validatedCard).to.not.be.undefined;
+                expect(validatedCard.Id).to.not.be.undefined;
+                expect(validatedCard.Type).to.equal("CARD_VALIDATION");
+            });
+        });
+
+        describe('Get Card Validation', function () {
+            before(function(done) {
+                api.Cards.getCardValidation(cardRegistration.CardId, validatedCard.Id, function(data) {
+                    fetchedCardValidation = data;
+                    done();
+                });
+            });
+
+            it('should fetch card validation', function () {
+                expect(fetchedCardValidation).to.not.be.undefined;
+                expect(fetchedCardValidation.Id).to.not.be.undefined;
+                expect(fetchedCardValidation.Id).to.equal(validatedCard.Id);
+                expect(fetchedCardValidation.Type).to.equal("CARD_VALIDATION");
+            });
+        });
+
+        describe('Check Card Existing', function () {
+            it('should be retrieved', function () {
+                expect(card.Id).to.not.be.undefined;
+                expect(card.Validity).to.equal('UNKNOWN');
+            });
+        });
+
+        describe('Get By Fingerprint', function() {
+            var cards;
+
+            before(function (done) {
+                api.Cards.getByFingerprint(card.Fingerprint, function(data, response) {
+                    cards = data;
+                    done();
+                });
+            });
+
+            it('should retrieve list', function () {
+                expect(cards).to.be.an('array');
+                cards.forEach(function (cardByFingerprint) {
+                    expect(cardByFingerprint.Fingerprint).to.equal(card.Fingerprint);
+                });
+            });
+        });
+
+        // test card deactivated
+        //describe('Update', function () {
+        //    var updatedCard;
+
+        //    before(function(done) {
+        //        updatedCard = {
+        //            Id: card.Id,
+        //            Validity: 'INVALID'
+        //        };
+        //        api.Cards.update(updatedCard, function(data, response){
+        //            updatedCard = data;
+        //            done();
+        //        });
+        //    });
+
+        //    it('should be updated', function () {
+        //        expect(updatedCard.Id).to.equal(card.Id);
+        //        expect(updatedCard.Active).to.be.false;
+        //    });
+        //});
+    });
+
+    describe('Creating Invalid user card registration', function () {
+        var newInvalidCardRegistration = {
+            UserId: '12345678',
+            Currency: 'EUR',
+            CardType: 'CB_VISA_MASTERCARD'
+          };
+        var failedResponse;
+
+        before(function(done) {
+          api.CardRegistrations.create(newInvalidCardRegistration, function (data) {
+              failedResponse = data;
+              done();
+          });
+        });
+
+        it('should fail', function () {
+            expect(failedResponse.Type).to.equal('ressource_not_found');
+        });
+    });
+});

package/test/services/Cards.js

@@ -0,0 +1,54 @@
+var _ = require('underscore');
+var expect = require('chai').expect;
+var helpers = require('../helpers');
+var UserNatural = require('../../lib/models/UserNatural');
+var api = require('../main');
+
+describe('Cards', function () {
+    var john = new UserNatural(helpers.data.getUserNatural());
+    var cardId;
+
+    before(function (done) {
+        api.Users.create(john).then(function (data, response) {
+            john = data;
+            done();
+        });
+    });
+
+    describe('Get PreAuthorizations', function () {
+        var getPreAuthorizations;
+
+        before(function (done) {
+            helpers.getNewPayInCardDirect(api, john, function (data) {
+                cardId = data.CardId;
+                api.Cards.getPreAuthorizations(cardId, function (data, response) {
+                    getPreAuthorizations = data;
+                    done();
+                });
+            });
+        });
+
+        it('should be retrieved', function () {
+            expect(getPreAuthorizations).not.to.be.undefined;
+            expect(getPreAuthorizations).to.be.an('array');
+        });
+    });
+
+    describe('Get Transactions for Card fingerprint', function(){
+        var getTransactions;
+
+        before(function(done){
+            api.Cards.get(cardId, function(data, response){
+                api.Cards.getTransactionsForFingerprint(data.Fingerprint, function(data, response){
+                    getTransactions = data;
+                    done();
+                });
+            });
+        });
+
+        it('should be retrieved', function(){
+            expect(getTransactions).not.to.be.undefined;
+            expect(getTransactions).to.be.an('array');
+        });
+    });
+});