mangopay4-nodejs-sdk 1.64.0

package/test/services/Events.js

@@ -0,0 +1,143 @@
+var _ = require('underscore');
+var expect = require('chai').expect;
+var api = require('../main');
+
+var helpers = require('../helpers');
+
+describe('Events', function() {
+    var john = helpers.data.getUserNatural();
+
+    before(function(done){
+        api.Users.create(john, function(){
+            done();
+        });
+    });
+
+    describe('Get Events List', function () {
+        describe('Payin Normal Created', function () {
+            var payIn, events;
+
+            before(function(done) {
+                helpers.getNewPayInCardWeb(api, john, function(data, response){
+                    payIn = data;
+                    api.Events.getAll(function(data, response){
+                        events = data;
+                        done();
+                    }, {
+                        parameters: {
+                            BeforeDate: payIn.CreationDate+10,
+                            AfterDate: payIn.CreationDate-10,
+                            EventType: 'PAYIN_NORMAL_CREATED'
+                        }
+                    })
+                });
+            });
+
+            it('should find created event', function () {
+                expect(events.length).to.be.above(0);
+                expect(_.findWhere(events, {ResourceId: payIn.Id})).to.exist;
+            });
+        });
+
+        describe('Payin Normal Succeeded', function () {
+            var payIn, events;
+
+            before(function(done) {
+                helpers.getNewPayInCardDirect(api, john, function(data, response){
+                    payIn = data;
+                    api.Events.getAll(function(data, response){
+                        events = data;
+                        done();
+                    }, {
+                        parameters: {
+                            BeforeDate: payIn.ExecutionDate+100,
+                            AfterDate: payIn.CreationDate-100,
+                            EventType: 'PAYIN_NORMAL_SUCCEEDED'
+                        }
+                    });
+                });
+            });
+
+            it('should find succeeded event', function () {
+                expect(events.length).to.be.above(0);
+                expect(_.findWhere(events, {ResourceId: payIn.Id})).to.exist;
+            });
+        });
+
+        describe('Payout Normal Created', function () {
+            var payOut, events;
+
+            before(function(done) {
+                helpers.getNewPayoutBankWire(api, john, async function (data, response) {
+                    payOut = data;
+                    // wait 2 seconds for the transactions to be created by the API
+                    const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+                    await delay(2000);
+
+                    api.Events.getAll(function (data, response) {
+                        events = data;
+                        done();
+                    }, {
+                        parameters: {
+                            BeforeDate: payOut.CreationDate + 10,
+                            AfterDate: payOut.CreationDate - 10,
+                            EventType: 'PAYOUT_NORMAL_CREATED'
+                        }
+                    })
+                });
+            });
+
+            it('should find payout created event', function () {
+                expect(events.length).to.be.above(0);
+                expect(_.findWhere(events, {ResourceId: payOut.Id})).to.exist;
+            });
+        });
+    });
+
+    describe('Get KYC Documents', function () {
+        var kycDocument, events;
+        before(function(done){
+            api.Users.createKycDocument(john.Id, {
+                Status: 'CREATED',
+                Type: 'IDENTITY_PROOF'
+            }).then(function(document){
+                kycDocument = document;
+                api.Events.getAll(function(data, response){
+                    events = data;
+                    done();
+                }, {
+                    parameters: {
+                        BeforeDate: kycDocument.CreationDate+10,
+                        AfterDate: kycDocument.CreationDate-10,
+                        EventType: 'KYC_CREATED'
+                    }
+                });
+            });
+        });
+
+        it('should find KYC Document event', function () {
+            expect(events.length).to.be.above(0);
+            expect(_.findWhere(events, {ResourceId: kycDocument.Id})).to.exist;
+        });
+    });
+
+    // TODO: Remove the .skip() call once Get Events endpoint is fixed on the server.
+    describe.skip('Get All Sort By Creation Date', function () {
+        var events;
+        before(function(done){
+            api.Events.getAll(function(data, response){
+                events = data;
+                done();
+            }, {
+                parameters: {
+                    Sort: 'CreationDate:asc'
+                }
+            });
+        });
+
+        it('should return events sorted', function () {
+            expect(events.length).to.be.above(0);
+            expect(events[1].Date).to.be.above(events[0].Date);
+        });
+    });
+});

package/test/services/Hooks.js

@@ -0,0 +1,109 @@
+var _ = require('underscore');
+var expect = require('chai').expect;
+var helpers = require('../helpers');
+var api = require('../main');
+
+describe('Hooks', function() {
+    var hook;
+
+    describe('Create', function () {
+        before(function (done) {
+            api.Hooks.getAll(function(data, response){
+                if (data.length) {
+                    hook = data[0];
+                    done();
+                } else {
+                    api.Hooks.create({
+                        EventType: 'PAYIN_NORMAL_CREATED',
+                        Url: 'http://test.com'
+                    }, function(data, response){
+                        hook = data;
+                        done()
+                    });
+                }
+            });
+        });
+
+        it('should be created', function () {
+            expect(hook.Id).to.exist;
+        });
+    });
+
+    describe('Get', function () {
+        var getHook;
+        before(function (done) {
+            api.Hooks.get(hook.Id, function(data, response){
+                getHook = data;
+                done();
+            });
+        });
+
+        it('should be the same as the created one', function () {
+            expect(getHook.Id).to.equal(hook.Id);
+        });
+    });
+
+    describe('Update', function () {
+        var updatedHook;
+        var newUrl = 'http://test123.com?_t=' + new Date().getTime();
+        before(function (done) {
+            hook.Url = newUrl;
+            api.Hooks.update(hook, function(data, response){
+                updatedHook = data;
+                done();
+            });
+        });
+
+        it('should be updated', function () {
+            expect(updatedHook.Url).to.equal(newUrl);
+        });
+    });
+
+ describe('Create User Kyc Regular', function () {
+        before(function (done) {
+            api.Hooks.getAll(function(data, response){
+                hook = data.find(x => x.EventType === "USER_KYC_REGULAR");
+                if (!hook){
+                    api.Hooks.create({
+                        EventType: 'USER_KYC_REGULAR',
+                        Url: 'http://test.com'
+                    }, function(data, response){
+                        hook = data;
+                        done();
+                    });
+                }
+                done();
+            }, {
+                parameters: {
+                    EventType: 'USER_KYC_REGULAR',
+                    Page: 1,
+                    Per_Page: 100
+                }
+            });
+        });
+
+        it('should be created', function () {
+            expect(hook.Id).to.exist;
+        });
+    });
+
+    describe('Get All', function () {
+        var hooks;
+        before(function (done) {
+            api.Hooks.getAll(function(data, response){
+                hooks = data;
+                done();
+            }, {
+                page: 1,
+                per_page: 50,
+                sort: "CreationDate:DESC"
+            });
+        });
+
+        it('should be > 0', function(){
+            expect(hooks.length).to.be.greaterThan(0);
+            expect(hooks[0].CreationDate).to.be.greaterThan(hooks[1].CreationDate);
+
+        });
+    });
+});

package/test/services/Idempotency.js

@@ -0,0 +1,46 @@
+var expect = require('chai').expect;
+var api = require('../main');
+
+var helpers = require('../helpers');
+var mangopay = require('../../index');
+
+var api = global.api = new mangopay({
+    clientId: 'sdk-unit-tests',
+    clientApiKey: 'cqFfFrWfCcb7UadHNxx2C9Lo6Djw8ZduLi7J9USTmu8bhxxpju'
+});
+
+describe('Idempotency', function () {
+    var idempotencyKey = helpers.generateRandomString();
+
+    describe('Get Valid Response', function () {
+        var validIdempotencyResponse;
+        var payIn;
+        var john = helpers.data.getUserNatural();
+
+        before(function (done) {
+            api.Users.create(john, function () {
+                done();
+            });
+        });
+
+        before(function (done) {
+            helpers.getNewPayInCardWebWithIdempotencyKey(api, john, idempotencyKey, function (data, response) {
+                payIn = data;
+                done();
+            });
+        });
+
+        before(function (done) {
+            api.Idempotency.get(idempotencyKey, function (data, response) {
+                validIdempotencyResponse = data;
+                done();
+            });
+        });
+
+        it('should get the Valid Idempotency Response', function () {
+            expect(validIdempotencyResponse.StatusCode).to.equal('200');
+            expect(validIdempotencyResponse.Resource).to.exist;
+        });
+    });
+
+});

package/test/services/IdentityVerifications.js

@@ -0,0 +1,68 @@
+var _ = require('underscore');
+var expect = require('chai').expect;
+var helpers = require('../helpers');
+var api = require('../main');
+const UserNatural = require("../../lib/models/UserNatural");
+
+describe('IdentityVerifications', function () {
+    var john = new UserNatural(helpers.data.getUserNatural());
+    var identityVerification;
+
+    before(function (done) {
+        api.Users.create(john).then(function (data, response) {
+            john = data;
+            const identityVerificationCreate = {
+                "ReturnUrl": "https://example.com",
+                "Tag": "Created using the NodeJS SDK"
+            };
+
+            api.IdentityVerifications.create(john.Id, identityVerificationCreate).then(function (data, response) {
+                identityVerification = data;
+                done();
+            });
+        });
+    });
+
+    describe('Create', function () {
+        it('should be created', function () {
+            expect(identityVerification).not.to.be.undefined;
+            expect(identityVerification.HostedUrl).not.to.be.undefined;
+            expect(identityVerification.ReturnUrl).not.to.be.undefined;
+            expect(identityVerification.Status).to.equal("PENDING");
+        });
+    });
+
+    describe('Get', function () {
+        var fetched;
+
+        before(function (done) {
+            api.IdentityVerifications.get(identityVerification.Id).then(function (data, response) {
+                fetched = data;
+                done();
+            });
+        });
+
+        it('should be fetched', function () {
+            expect(fetched).not.to.be.undefined;
+            expect(fetched.HostedUrl).to.equal(identityVerification.HostedUrl);
+            expect(fetched.ReturnUrl).to.equal(identityVerification.ReturnUrl);
+            expect(fetched.Status).to.equal(identityVerification.Status);
+        });
+    });
+
+    describe('Get All', function () {
+        var fetched;
+
+        before(function (done) {
+            api.IdentityVerifications.getAll(john.Id).then(function (data, response) {
+                fetched = data;
+                done();
+            });
+        });
+
+        it('should be fetched', function () {
+            expect(fetched).not.to.be.undefined;
+            expect(fetched.length).to.be.above(0);
+        });
+    });
+});

package/test/services/KycDocuments.js

@@ -0,0 +1,73 @@
+var _ = require('underscore');
+var expect = require('chai').expect;
+var helpers = require('../helpers');
+var api = require('../main');
+
+describe('KycDocuments', function() {
+    var john = helpers.data.getUserNatural();
+    var document;
+
+    before(function(done){
+        api.Users.create(john).then(function(){
+            api.Users.createKycDocument(john.Id, {
+                Status: 'CREATED',
+                Type: 'IDENTITY_PROOF',
+                Tag: "custom meta"
+            }).then(function(data){
+                document = data;
+                done();
+            });
+        });
+    });
+
+    describe('Get All', function () {
+        var documents;
+        before(function(done){
+             api.KycDocuments.getAll(function(data, response){
+                 documents = data;
+                 done();
+             }, {
+                 parameters: {
+                     AfterDate: document.CreationDate - 10,
+                     BeforeDate: document.CreationDate + 10
+                 }
+             });
+        });
+
+        it('should contain the created document', function () {
+            expect(_.findWhere(documents, {Id: document.Id})).to.exist;
+        });
+    });
+
+    describe('Get', function () {
+        var getDocument;
+        before(function(done){
+            api.KycDocuments.get(document.Id, function(data, response){
+                getDocument = data;
+                done();
+            });
+        });
+
+        it('should get the document', function () {
+            expect(getDocument.Id).to.equal(document.Id);
+            expect(getDocument.Flags).not.to.be.undefined;
+            expect(getDocument.Flags).to.be.an('array');
+        });
+    });
+
+    describe('Create KYC Document Consult', function () {
+        var consults;
+
+        before(function(done) {
+            api.KycDocuments.createKycDocumentConsult(document.Id, function(data, response) {
+                consults = data;
+                done();
+            });
+        });
+
+        it('should be created', function () {
+            expect(consults).not.to.be.undefined;
+            expect(consults).to.be.an('array');
+        });
+    });
+});

package/test/services/Mandates.js

@@ -0,0 +1,256 @@
+var _ = require('underscore');
+var path = require('path');
+var Promise = require('promise');
+var expect = require('chai').expect;
+var assert = require('chai').assert;
+var os = require('os');
+var api = require('../main');
+
+var helpers = require('../helpers');
+
+var Mandate = require('../../lib/models/Mandate');
+var UserNatural = require('../../lib/models/UserNatural');
+var BankAccount = require('../../lib/models/BankAccount');
+var BankAccountDetailsIBAN = require('../../lib/models/BankAccountDetailsIBAN');
+var Wallet = require('../../lib/models/Wallet');
+var PayIn = require('../../lib/models/PayIn');
+
+describe('Mandates', function() {
+    var ibanAccount, mandate;
+    var john = new UserNatural(_.extend(helpers.data.getUserNatural()));
+
+    before(function(done){
+        api.Users.create(john).then(function(data){
+            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(data){
+                ibanAccount = data;
+
+                mandate = new Mandate({
+                    Tag: 'custom meta',
+                    BankAccountId: ibanAccount.Id,
+                    Culture: 'EN',
+                    ReturnURL: 'http://www.my-site.com/returnURL/'
+                });
+
+                api.Mandates.create(mandate, function(data){
+                    mandate = data;
+                    done();
+                });
+
+            });
+        });
+    });
+
+    it('should be created with the right properties', function(){
+        expect(mandate.Id).not.to.be.undefined;
+        expect(mandate.BankAccountId).to.equal(ibanAccount.Id);
+        expect(mandate.MandateType).to.equal('DIRECT_DEBIT');
+        expect(mandate.ExecutionType).to.equal('WEB');
+        expect(mandate.ReturnURL).to.equal('http://www.my-site.com/returnURL/?MandateId=' + mandate.Id);
+        expect(mandate.Tag).to.equal('custom meta');
+        expect(mandate.Status).to.equal('CREATED');
+    });
+
+    describe('Get created mandate', function() {
+        before(function(done){
+            api.Mandates.get(mandate.Id, function(data){
+                mandate = data;
+                done();
+            });
+        });
+
+        it('should be received with the right properties', function(){
+            expect(mandate.Id).not.to.be.undefined;
+            expect(mandate.BankAccountId).to.equal(ibanAccount.Id);
+            expect(mandate.MandateType).to.equal('DIRECT_DEBIT');
+            expect(mandate.ExecutionType).to.equal('WEB');
+            expect(mandate.ReturnURL).to.equal('http://www.my-site.com/returnURL/?MandateId=' + mandate.Id);
+            expect(mandate.Tag).to.equal('custom meta');
+            expect(mandate.Status).to.equal('CREATED');
+        });
+    });
+
+    describe('Get all mandates', function() {
+        var mandates;
+
+        before(function(done){
+            api.Mandates.getAll(function(data){
+                mandates = data;
+                done();
+            });
+        });
+
+        it('should be retrieve at least one mandate', function(){
+            expect(mandates.length).to.be.above(1);
+        });
+    });
+
+    describe('Cancel a mandate before being approved it - CREATED status', function() {
+        var cancelResponse;
+        before(function(done){
+            api.Mandates.cancel(mandate.Id, function(data){
+                cancelResponse = data;
+                done();
+            });
+        });
+
+        it('shouldn\'t be able to cancel a mandate with the status "CREATED"', function(){
+            expect(cancelResponse.Type).to.equal('mandate_cannot_be_cancelled');
+        });
+    });
+
+    describe('Create DirectDebit Direct Payin before being approved - "CREATED" status', function() {
+        var payIn, wallet;
+
+        before(function(done){
+            wallet = new Wallet({
+                Owners: [john.Id],
+                Currency: 'EUR',
+                Description: 'WALLET IN EUR'
+            });
+
+            api.Wallets.create(wallet).then(function(data){
+                wallet = data;
+
+                payIn = new PayIn({
+                    CreditedWalletId: wallet.Id,
+                    AuthorId: john.Id,
+                    DebitedFunds: {
+                        Amount: 10000,
+                        Currency: 'EUR'
+                    },
+                    Fees: {
+                        Amount: 0,
+                        Currency: 'EUR'
+                    },
+                    PaymentType: 'DIRECT_DEBIT',
+                    ExecutionType: 'DIRECT',
+                    MandateId: mandate.Id
+                });
+
+                api.PayIns.create(payIn, function(data) {
+                    payIn = data;
+                    done();
+                });
+            });
+        });
+
+        it('should be created successfully but with "FAILED" status', function(){
+            expect(payIn.AuthorId).to.equal(john.Id);
+            expect(payIn.CreditedUserId).to.equal(john.Id);
+            expect(payIn.CreditedWalletId).to.equal(wallet.Id);
+            expect(payIn.Status).to.equal('FAILED');
+        });
+    });
+
+    /**
+     * Check if the OS platform has a GUI ( MacOS / Windows ) and if the tests are running
+     * in debugging mode. Otherwise this test cannot run, since a user action is required
+     * inside the browser, for approving the Mandate (clicking the "CONFIRM" button)
+     */
+    if ((os.platform() === 'darwin' || os.platform() === 'win32') && process.execArgv && process.execArgv[0] && process.execArgv[0].match(/--debug-brk/)) {
+        describe('After approving the mandate', function() {
+            before(function(done){
+                /**
+                 * ! IMPORTANT NOTE !
+                 *
+                 * In order to make this test pass debugging mode is required to stop at the breakpoint below
+                 * and navigate to URL the mandate.RedirectURL property points to and click "CONFIRM" button.
+                 *
+                 * The command above is supposed to open your default browser window with that link for you:
+                 */
+                var spawn = require('child_process').spawn;
+                spawn('open',  [mandate.RedirectURL]);
+
+                debugger;
+                done();
+            });
+
+            describe('Create DirectDebit Direct Payin after being approved', function() {
+                var payIn, wallet;
+
+                before(function(done){
+                    wallet = new Wallet({
+                        Owners: [john.Id],
+                        Currency: 'EUR',
+                        Description: 'WALLET IN EUR'
+                    });
+
+                    api.Wallets.create(wallet).then(function(data){
+                        wallet = data;
+
+                        payIn = new PayIn({
+                            CreditedWalletId: wallet.Id,
+                            AuthorId: john.Id,
+                            DebitedFunds: {
+                                Amount: 10000,
+                                Currency: 'EUR'
+                            },
+                            Fees: {
+                                Amount: 0,
+                                Currency: 'EUR'
+                            },
+                            PaymentType: 'DIRECT_DEBIT',
+                            ExecutionType: 'DIRECT',
+                            MandateId: mandate.Id
+                        });
+
+                        api.PayIns.create(payIn, function(data) {
+                            payIn = data;
+                            done();
+                        });
+                    });
+                });
+
+                it('should be created successfully but with the right status', function(){
+                    expect(payIn.AuthorId).to.equal(john.Id);
+                    expect(payIn.CreditedUserId).to.equal(john.Id);
+                    expect(payIn.CreditedWalletId).to.equal(wallet.Id);
+                    expect(payIn.MandateId).to.equal(mandate.Id);
+                    expect(payIn.Status).to.equal('CREATED');
+                });
+            });
+
+            describe('Cancel a mandate after being confirmed', function() {
+                var cancelResponse;
+
+                before(function(done){
+                    api.Mandates.cancel(mandate.Id, function(data){
+                        cancelResponse = data;
+                        done();
+                    });
+                });
+
+                it('should set the mandate status to "FAILED"', function(){
+                    expect(cancelResponse.Status).to.equal('FAILED');
+                });
+            });
+        });
+    }
+
+    describe('Get Transactions', function() {
+        var getTransactions;
+
+        before(function(done) {
+            api.Mandates.getTransactions(mandate.Id, function(data) {
+                getTransactions = data;
+                done();
+            });
+        });
+
+        it('should be retrieved', function() {
+            expect(getTransactions).not.to.be.undefined;
+            expect(getTransactions).to.be.an('array');
+        });
+    });
+});