mangopay4-nodejs-sdk 1.64.0

package/test/services/PayOuts.js

@@ -0,0 +1,106 @@
+var expect = require('chai').expect;
+var api = require('../main');
+var helpers = require('../helpers');
+
+describe('PayOuts', function() {
+    var john = helpers.data.getUserNatural();
+    var payOut;
+
+    before(function(done){
+        api.Users.create(john, function(){
+            done();
+        });
+    });
+
+    describe('Create', function() {
+        before(function(done){
+            helpers.getNewPayoutBankWire(api, john, function(data, response){
+                payOut = data;
+                done();
+            });
+        });
+
+        it('should be created', function(){
+            expect(payOut.Id).to.exist;
+            expect(payOut.PaymentType).to.equal('BANK_WIRE');
+        });
+    });
+
+    describe('Get', function() {
+        var getPayOut;
+
+        before(function(done){
+            api.PayOuts.get(payOut.Id, function(data, response){
+                getPayOut = data;
+                done();
+            });
+        });
+
+        it('should be fetched', function(){
+            expect(payOut.Id).to.equal(getPayOut.Id);
+            expect(payOut.Status).to.equal('CREATED');
+            expect(payOut.ExecutionDate).to.be.null;
+        });
+
+        describe('Get Bankwire', function() {
+            var getBankwire;
+
+            before(function(done){
+                api.PayOuts.getBankwire(payOut.Id, function(data, response){
+                    getBankwire = data;
+                    done();
+                });
+            });
+
+            it('should be fetched', function(){
+                expect(payOut.Id).to.equal(getPayOut.Id);
+                expect(payOut.Status).to.equal('CREATED');
+                expect(payOut.ExecutionDate).to.be.null;
+                expect(payOut.ModeRequested).to.equal('STANDARD');
+            });
+        });
+    });
+
+    describe('Get Refunds', function() {
+        var getRefunds;
+
+        before(function(done) {
+            api.PayOuts.getRefunds(payOut.Id, function(data, response) {
+                getRefunds = data;
+                done();
+            });
+        });
+
+        it('should be retrieved', function() {
+            expect(getRefunds).not.to.be.undefined;
+            expect(getRefunds).to.be.an('array');
+        })
+    })
+
+    describe('Check Eligibility', function() {
+        var eligibility;
+
+        before(function(done) {
+            helpers.getNewPayoutBankWire(api, john, function(data, response){
+                var eligibilityDto = {
+                    AuthorId: data.AuthorId,
+                    DebitedFunds: data.DebitedFunds,
+                    BankAccountId: data.BankAccountId,
+                    DebitedWalletId: data.DebitedWalletId,
+                    PayoutModeRequested: "INSTANT_PAYMENT"
+                };
+
+                api.PayOuts.checkEligibility(eligibilityDto, function(data, response) {
+                    eligibility = data;
+                    done();
+                });
+            });
+        });
+
+        it('should be retrieved', function() {
+            expect(eligibility.InstantPayout).not.to.be.undefined;
+            expect(eligibility.InstantPayout.IsReachable).not.to.be.undefined;
+            expect(eligibility.InstantPayout.UnreachableReason).not.to.be.undefined; //will be undefined if IsReachable true
+        })
+    })
+});

package/test/services/RateLimit.js

@@ -0,0 +1,48 @@
+var expect = require('chai').expect;
+var helpers = require('../helpers');
+const mangopay = require("../../index");
+
+var api = global.api = new mangopay({
+    clientId: 'sdk-unit-tests',
+    clientApiKey: 'cqFfFrWfCcb7UadHNxx2C9Lo6Djw8ZduLi7J9USTmu8bhxxpju'
+});
+
+describe('Rate Limits', function () {
+    expect(api.rateLimits).to.be.empty;
+    var john = helpers.data.getUserNatural();
+
+    before(function (done) {
+        api.Users.create(john).then(function () {
+            done();
+        });
+    });
+
+    describe('Exist', function () {
+        it('should exist', function () {
+            expect(john.Id).to.exist;
+
+            expect(api.rateLimits).not.to.be.empty;
+            expect(api.rateLimits.length).to.equal(4);
+
+            expect(api.rateLimits[0].minutesInterval).to.equal(15);
+            expect(api.rateLimits[1].minutesInterval).to.equal(30);
+            expect(api.rateLimits[2].minutesInterval).to.equal(60);
+            expect(api.rateLimits[3].minutesInterval).to.equal(60 * 24);
+
+            expect(api.rateLimits[0].callsMade).to.be.greaterThan(0);
+            expect(api.rateLimits[1].callsMade).to.be.greaterThan(0);
+            expect(api.rateLimits[2].callsMade).to.be.greaterThan(0);
+            expect(api.rateLimits[3].callsMade).to.be.greaterThan(0);
+
+            expect(api.rateLimits[0].callsRemaining).to.be.greaterThan(0);
+            expect(api.rateLimits[1].callsRemaining).to.be.greaterThan(0);
+            expect(api.rateLimits[2].callsRemaining).to.be.greaterThan(0);
+            expect(api.rateLimits[3].callsRemaining).to.be.greaterThan(0);
+
+            expect(api.rateLimits[0].resetTimeMillis).to.be.greaterThan(0);
+            expect(api.rateLimits[1].resetTimeMillis).to.be.greaterThan(0);
+            expect(api.rateLimits[2].resetTimeMillis).to.be.greaterThan(0);
+            expect(api.rateLimits[3].resetTimeMillis).to.be.greaterThan(0);
+        });
+    });
+});

package/test/services/Recipients.js

@@ -0,0 +1,234 @@
+var expect = require('chai').expect;
+var helpers = require('../helpers');
+var api = require('../main');
+
+describe('Recipients', function() {
+    var john = helpers.data.getUserNaturalScaOwner();
+    var recipient;
+
+    before(function(done){
+        api.Users.create(john).then(function(data){
+            john = data;
+            const createRecipient = {
+                DisplayName: "My EUR account",
+                PayoutMethodType: "LocalBankTransfer",
+                RecipientType: "Individual",
+                Currency: "EUR",
+                Country: "DE",
+                IndividualRecipient: {
+                    FirstName: "John",
+                    LastName: "Doe",
+                    Address: {
+                        AddressLine1: "10 Kingsway",
+                        City: "London",
+                        PostalCode: "WC2B 6LH",
+                        Country: "DE"
+                    }
+                },
+                LocalBankTransfer: {
+                    EUR: {
+                        IBAN: "DE75512108001245126199"
+                    }
+                },
+                ScaContext: "USER_PRESENT"
+            };
+            api.Recipients.create(createRecipient, john.Id).then(function(data){
+                recipient = data;
+                done();
+            });
+        });
+    });
+
+    describe('Create', function () {
+        it('should be correctly created', function () {
+            expect(recipient.Id).to.not.be.null;
+            expect(recipient.Status).to.not.be.null;
+            expect(recipient.DisplayName).to.not.be.null;
+            expect(recipient.PayoutMethodType).to.not.be.null;
+            expect(recipient.RecipientType).to.not.be.null;
+            expect(recipient.IndividualRecipient).to.not.be.null;
+            expect(recipient.LocalBankTransfer).to.not.be.null;
+            expect(recipient.PendingUserAction).to.not.be.null;
+            expect(recipient.RecipientVerificationOfPayee).to.not.be.null;
+        });
+    });
+
+    describe('GET', function () {
+        var fetched;
+        before(function(done){
+            api.Recipients.get(recipient.Id).then(function(data){
+                fetched = data;
+                done();
+            });
+        });
+
+        it('should be correctly fetched', function () {
+            expect(fetched.Id).to.not.be.null;
+            expect(fetched.Id).to.be.eq(recipient.Id);
+        });
+    });
+
+    describe('GET User Recipients', function () {
+        var recipientsList;
+        before(function(done){
+            api.Recipients.getUserRecipients(john.Id, function(data){
+                recipientsList = data;
+                done();
+            },
+                {
+                    parameters: {
+                        RecipientScope: "PAYOUT"
+                    }
+                }
+            );
+        });
+
+        it('should be correctly fetched', function () {
+            expect(recipientsList).to.not.be.null;
+            expect(recipientsList.length).to.be.gt(0);
+        });
+    });
+
+    describe('GET User Recipients PAYIN', function () {
+        var recipientsList;
+        before(function(done){
+            api.Recipients.getUserRecipients(john.Id, function(data){
+                    recipientsList = data;
+                    done();
+                },
+                {
+                    parameters: {
+                        RecipientScope: "PAYIN"
+                    }
+                }
+            );
+        });
+
+        it('should be correctly fetched', function () {
+            expect(recipientsList).to.not.be.null;
+            expect(recipientsList.length).to.be.eq(0);
+        });
+    });
+
+    describe('GET Schema LocalBankTransfer Individual', function () {
+        var schema;
+        before(function(done){
+            api.Recipients.getSchema("LocalBankTransfer", "Individual", "GBP", "GB").then(function(data){
+                schema = data;
+                done();
+            });
+        });
+
+        it('should be correctly fetched', function () {
+            expect(schema).to.not.be.null;
+            expect(schema.DisplayName).to.not.be.null;
+            expect(schema.Currency).to.not.be.null;
+            expect(schema.RecipientType).to.not.be.null;
+            expect(schema.PayoutMethodType).to.not.be.null;
+            expect(schema.RecipientScope).to.not.be.null;
+            expect(schema.Tag).to.not.be.null;
+            expect(schema.LocalBankTransfer).to.not.be.null;
+            expect(schema.IndividualRecipient).to.not.be.null;
+            expect(schema.InternationalBankTransfer).to.be.undefined;
+            expect(schema.BusinessRecipient).to.be.undefined;
+
+        });
+    });
+
+    describe('GET Schema InternationalBankTransfer Business', function () {
+        var schema;
+        before(function(done){
+            api.Recipients.getSchema("InternationalBankTransfer", "Business", "GBP", "GB").then(function(data){
+                schema = data;
+                done();
+            });
+        });
+
+        it('should be correctly fetched', function () {
+            expect(schema).to.not.be.null;
+            expect(schema.DisplayName).to.not.be.null;
+            expect(schema.Currency).to.not.be.null;
+            expect(schema.RecipientType).to.not.be.null;
+            expect(schema.PayoutMethodType).to.not.be.null;
+            expect(schema.RecipientScope).to.not.be.null;
+            expect(schema.Tag).to.not.be.null;
+            expect(schema.InternationalBankTransfer).to.not.be.null;
+            expect(schema.BusinessRecipient).to.not.be.null;
+            expect(schema.LocalBankTransfer).to.be.undefined;
+            expect(schema.IndividualRecipient).to.be.undefined;
+        });
+    });
+
+    describe('GET Payout Methods', function () {
+        var payoutMethods;
+        before(function(done){
+            api.Recipients.getPayoutMethods("DE", "GBP").then(function(data){
+                payoutMethods = data;
+                done();
+            });
+        });
+
+        it('should be correctly fetched', function () {
+            expect(payoutMethods).to.not.be.null;
+            expect(payoutMethods.AvailablePayoutMethods.length).to.be.gt(0);
+        });
+    });
+
+    describe('Validate recipient passes', function () {
+        before(function(done){
+            api.Recipients.validate(recipient, john.Id).then(function(){
+                done();
+            });
+        });
+
+        it('should work', function () {
+            // dummy check (if the request doesn't work, it will throw error and not get here)
+            expect(true).to.eq(true);
+        });
+    });
+
+    describe('Validate Recipient fails', function () {
+        var errorResult;
+
+        before(function (done) {
+            const currency = recipient.Currency;
+            recipient.Currency = undefined;
+            api.Recipients.validate(recipient, john.Id).then(function (data) {
+                done();
+            })
+                .catch(function (error) {
+                    errorResult = error;
+                    // put back the currency
+                    recipient.Currency = currency;
+                    done();
+                });
+        });
+
+        it('Should return error for missing param', function(){
+            expect(errorResult.Message).to.contain("One or several required parameters are missing or incorrect");
+        });
+    });
+
+    describe.skip('Deactivate', function () {
+        console.warn("A recipient needs to be manually activated before running the test");
+        var fetched;
+        var deactivated;
+        before(function(done){
+            api.Recipients.deactivate(recipient.Id).then(function(data){
+                deactivated = data;
+                api.Recipients.get(recipient.Id).then(function(data){
+                    fetched = data;
+                    done();
+                });
+            });
+        });
+
+        it('should be deactivated', function () {
+            expect(deactivated.Id).to.not.be.null;
+            expect(fetched.Id).to.not.be.null;
+            expect(recipient.Status).to.eq("PENDING");
+            expect(deactivated.Status).to.eq("DEACTIVATED");
+            expect(fetched.Status).to.eq("DEACTIVATED");
+        });
+    });
+});

package/test/services/Refunds.js

@@ -0,0 +1,123 @@
+var expect = require('chai').expect;
+var helpers = require('../helpers');
+var api = require('../main');
+
+describe('Refunds', function() {
+    var john = helpers.data.getUserNatural();
+    var wallet, secondWallet, transfer, cardRegistration, card;
+
+    before('Create a wallet with money, one without money, and a transfer', function(done){
+        api.Users.create(john).then(function(){
+            wallet = {
+                Owners: [john.Id],
+                Currency: 'EUR',
+                Description: 'WALLET IN EUR'
+            };
+            secondWallet = {
+                Owners: [john.Id],
+                Currency: 'EUR',
+                Description: 'WALLET IN EUR'
+            };
+            cardRegistration = {
+                UserId: john.Id,
+                Currency: 'EUR'
+            };
+            api.Wallets.create(wallet).then(function(){
+                api.CardRegistrations.create(cardRegistration, function(){
+                    helpers.getPaylineCorrectRegistartionData(cardRegistration, function(data, response){
+                        cardRegistration.RegistrationData = data;
+                        api.CardRegistrations.update(cardRegistration).then(function(data){
+                            cardRegistration = data;
+                            api.Cards.get(cardRegistration.CardId, function(data, response){
+                                card = data;
+                                api.PayIns.create({
+                                    CreditedWalletId: wallet.Id,
+                                    AuthorId: john.Id,
+                                    DebitedFunds: {
+                                        Amount: 100,
+                                        Currency: 'EUR'
+                                    },
+                                    Fees: {
+                                        Amount: 0,
+                                        Currency: 'EUR'
+                                    },
+                                    CardId: card.Id,
+                                    SecureMode: 'DEFAULT',
+                                    SecureModeReturnURL: 'https://test.com',
+                                    PaymentType: 'CARD',
+                                    ExecutionType: 'DIRECT',
+                                    BrowserInfo: {
+                                        AcceptHeader: "text/html, application/xhtml+xml, application/xml;q=0.9, /;q=0.8",
+                                        JavaEnabled: true,
+                                        Language: "FR-FR",
+                                        ColorDepth: 4,
+                                        ScreenHeight: 1800,
+                                        ScreenWidth: 400,
+                                        JavascriptEnabled: true,
+                                        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"
+                                    },
+                                    IpAddress: "2001:0620:0000:0000:0211:24FF:FE80:C12C"
+                                }, function(data, response){
+                                    api.Wallets.create(secondWallet).then(function(){
+                                        api.Transfers.create({
+                                            AuthorId: john.Id,
+                                            Tag: 'DefaultTag',
+                                            CreditedUserId: john.Id,
+                                            DebitedFunds: {
+                                                Currency: 'EUR',
+                                                Amount: 1
+                                            },
+                                            Fees: {
+                                                Currency: 'EUR',
+                                                Amount: 0
+                                            },
+                                            DebitedWalletId: wallet.Id,
+                                            CreditedWalletId: secondWallet.Id
+                                        }, function(data, response){
+                                            transfer = data;
+                                            api.Wallets.get(wallet.Id).then(function (data) {
+                                                wallet = data;
+                                                done();
+                                            });
+                                        });
+                                    });
+                                });
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    });
+
+    describe('Get for transfer', function () {
+        var refund;
+        before(function(done){
+            refund = {
+                DebitedWalletId: transfer.DebitedWalletId,
+                CreditedWalletId: transfer.CreditedWalletId,
+                AuthorId: john.Id,
+                DebitedFunds: {
+                    Amount: transfer.DebitedFunds.Amount,
+                    Currency: transfer.DebitedFunds.Currency
+                },
+                Fees: {
+                    Amount: transfer.Fees.Amount,
+                    Currency: transfer.DebitedFunds.Currency
+                }
+            };
+            api.Transfers.createRefund(transfer.Id, refund, function(data, response){
+                refund = data;
+                done();
+            });
+        });
+
+        it('should be refunded', function () {
+            expect(refund.InitialTransactionId).to.equal(transfer.Id);
+            expect(refund.AuthorId).to.equal(john.Id);
+            expect(refund.Type).to.equal('TRANSFER');
+            expect(refund.Nature).to.equal('REFUND');
+        });
+    });
+});

package/test/services/Regulatory.js

@@ -0,0 +1,45 @@
+var expect = require('chai').expect;
+var api = require('../main');
+
+describe('Regulatory', function() {
+
+    describe('Get Authorizations For One Country', function () {
+        var countryAuthorization;
+
+        before(function(done){
+            api.Regulatory.getCountryAuthorizations("FR", function(data, response){
+                countryAuthorization = data;
+                done();
+            });
+        });
+
+        it('should be returned', function () {
+            expect(countryAuthorization).not.to.be.undefined;
+            expect(countryAuthorization.CountryCode).not.to.be.undefined;
+            expect(countryAuthorization.CountryName).not.to.be.undefined;
+            expect(countryAuthorization.Authorization).not.to.be.undefined;
+            expect(countryAuthorization.LastUpdate).not.to.be.undefined;
+        });
+    });
+
+    describe('Get Authorizations For All Countries', function () {
+        var countryAuthorizations;
+
+        before(function(done){
+            api.Regulatory.getAllCountriesAuthorizations(function(data, response){
+                countryAuthorizations = data;
+                done();
+            });
+        });
+
+        it('should be returned', function () {
+            expect(countryAuthorizations).not.to.be.undefined;
+            expect(countryAuthorizations).not.to.be.empty;
+
+            expect(countryAuthorizations[0].CountryCode).not.to.be.undefined;
+            expect(countryAuthorizations[0].CountryName).not.to.be.undefined;
+            expect(countryAuthorizations[0].Authorization).not.to.be.undefined;
+            expect(countryAuthorizations[0].LastUpdate).not.to.be.undefined;
+        });
+    });
+});

package/test/services/Reports.js

@@ -0,0 +1,114 @@
+var expect = require('chai').expect;
+var helpers = require('../helpers');
+var api = require('../main');
+
+describe('Reports - Transactions', function () {
+    var report;
+
+    before(function (done) {
+        report = {
+            ReportType: "TRANSACTIONS",
+            Tag: 'Created with Mangopay NodeJs SDK',
+            DownloadFormat: 'CSV',
+            CallbackURL: 'https://mangopay.com/docs/please-ignore',
+            Sort: 'CreationDate:ASC',
+            Preview: false,
+            Filters:
+                {
+                    BeforeDate: 1756293864,
+                    AfterDate: 1753615463,
+                    Type: ['PAYIN'],
+                    ResultCode: ['000000'],
+                    Status: ['SUCCEEDED'],
+                    Nature: ['REGULAR'],
+                    WalletId: null,
+                    AuthorId: null,
+                    MinDebitedFundsAmount: 10,
+                    MinDebitedFundsCurrency: 'EUR',
+                    MaxDebitedFundsAmount: 12000,
+                    MaxDebitedFundsCurrency: 'EUR',
+                    MinFeesAmount: 10,
+                    MinFeesCurrency: 'EUR',
+                    MaxFeesAmount: 150000,
+                    MaxFeesCurrency: 'EUR',
+                },
+            Columns: [
+                'Id',
+                'Tag',
+                'CreationDate',
+                'ExecutionDate',
+                'AuthorId',
+                'CreditedUserId',
+                'DebitedFundsAmount',
+                'DebitedFundsCurrency',
+                'CreditedFundsAmount',
+                'CreditedFundsCurrency',
+                'FeesAmount',
+                'FeesCurrency',
+                'Status',
+                'ResultCode',
+                'ResultMessage',
+                'Type',
+                'Nature',
+                'CreditedWalletId',
+                'DebitedWalletId',
+            ]
+        };
+        api.Reports.create(report).then(function (data) {
+            done();
+        });
+    });
+
+    it('should exist after creating it', function () {
+        expect(report.Id).to.exist;
+    });
+
+    describe('Getting created report', function () {
+        var getReport;
+
+        before(function (done) {
+            api.Reports.get(report.Id).then(function (data) {
+                getReport = data;
+                done();
+            });
+        });
+
+        it('should be correctly fetched', function () {
+            expect(report.Id).to.equal(getReport.Id);
+            expect(report.CreationDate).to.equal(getReport.CreationDate);
+        });
+    });
+});
+
+describe('Reports - Wallets', function () {
+    var report;
+
+    before(function (done) {
+        report = {
+            ReportType: "WALLETS"
+        };
+        api.Reports.create(report).then(function () {
+            done();
+        });
+    });
+
+    it('should exist after creting it', function () {
+        expect(report.Id).to.exist;
+    });
+
+    describe('Getting created report', function () {
+        var getReport;
+
+        before(function (done) {
+            api.Reports.get(report.Id).then(function (data) {
+                getReport = data;
+                done();
+            });
+        });
+
+        it('should be correctly fetched', function () {
+            expect(report.Id).to.equal(getReport.Id);
+            expect(report.CreationDate).to.equal(getReport.CreationDate);
+        });
+    });
+});