mangopay 2.0.0

data/spec/lib/mangopay/operation_spec.rb

@@ -0,0 +1,8 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::Operation do
+
+    it "gets the operation" do
+        operation = MangoPay::Operation.get(1)
+    end
+end

data/spec/lib/mangopay/recurrent_contribution_spec.rb

@@ -0,0 +1,55 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::RecurrentContribution do
+
+    let(:new_user) {
+        MangoPay::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+
+    let(:new_recurrent_contribution) {
+        MangoPay::RecurrentContribution.create({
+            'Tag' => 'test-recurrent-contribution',
+            'UserID' => new_user['ID'],
+            'WalletID' => 0,
+            'Amount' => 4200,
+            'StartDate' => '1388534400',
+            'FrequencyCode' => 'TwiceMonthly',
+            'NumberOfExecutions' => 10,
+            'ReturnURL' => 'http://leetchi.com'
+            })
+    }
+
+    describe "CREATE" do
+        it "create a new recurrent contribution and return a PaymentURL" do
+            expect(new_recurrent_contribution['PaymentURL']).not_to be_empty
+        end
+    end
+
+    describe "GET" do
+        it "get a recurrent contribution" do
+            recurrent_contribution = MangoPay::RecurrentContribution.get(new_recurrent_contribution["ID"])
+            expect(recurrent_contribution["ID"]).to eq(new_recurrent_contribution["ID"])
+        end
+    end
+
+    describe "UPDATE" do
+        it "updates a recurrent contribution" do
+            recurrent_contribution = MangoPay::RecurrentContribution.update(new_recurrent_contribution["ID"], { :IsEnabled => false })
+            expect(recurrent_contribution["IsEnabled"]).to be_false
+        end
+    end
+
+    describe "GET_EXECUTIONS" do
+        it "get a list of the recurrent contribution executions" do
+            recurrent_contribution_executions = MangoPay::RecurrentContribution.get_executions(new_recurrent_contribution["ID"])
+            expect(recurrent_contribution_executions).to be_a_kind_of(Array)
+            expect(recurrent_contribution_executions).to be_empty
+        end
+    end
+end

data/spec/lib/mangopay/ressource_spec.rb

@@ -0,0 +1,5 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::Ressource do
+    pending "It should test the ressource"
+end

data/spec/lib/mangopay/strong_authentication_spec.rb

@@ -0,0 +1,82 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::StrongAuthentication do
+
+  let(:new_user) {
+    MangoPay::User.create({
+      'Tag' => 'test',
+      'Email' => 'my@email.com',
+      'FirstName' => 'John',
+      'LastName' => 'Doe',
+      'CanRegisterMeanOfPayment' => true
+      })
+  }
+
+  let(:new_beneficiary) {
+    MangoPay::Beneficiary.create({
+      'Tag' => 'test',
+      'UserID' => new_user['ID'],
+      'BankAccountOwnerName' => new_user['FirstName'],
+      'BankAccountOwnerAddress' => '1 bis cite paradis',
+      'BankAccountIBAN' => 'FR76 1790 6000 3200 0833 5232 973',
+      'BankAccountBIC' => 'AGRIFRPP879'
+      })
+  }
+
+  let(:new_strong_beneficiary_authentication) {
+    MangoPay::Beneficiary.create_strong_authentication(new_beneficiary['ID'], {
+      'Tag' => 'test_beneficiary_strong_authentication'
+      })
+  }
+
+  let(:new_strong_user_authentication) {
+    MangoPay::User.create_strong_authentication(new_user['ID'], {
+      'Tag' => 'test_user_strong_authentication'
+      })
+  }
+
+  describe "GET" do
+    it "get the pending strong authentication requests" do
+      strong_authentication = MangoPay::StrongAuthentication.get
+      expect(strong_authentication).to be_kind_of(Array)
+    end
+  end
+
+  describe "UPLOAD BENEFICIARY" do
+    it "uploads a PDF file to complete a beneficiary strong authentication request" do
+      document_upload = MangoPay::StrongAuthentication.upload(new_strong_beneficiary_authentication['UrlRequest'], 'spec/support-files/test_upload.pdf')
+      expect(document_upload).to be_true
+    end
+    it "uploads a JPG file to complete a beneficiary strong authentication request" do
+      document_upload = MangoPay::StrongAuthentication.upload(new_strong_beneficiary_authentication['UrlRequest'], 'spec/support-files/test_upload.jpg')
+      expect(document_upload).to be_true
+    end
+    it "uploads a PNG file to complete a beneficiary strong authentication request" do
+      document_upload = MangoPay::StrongAuthentication.upload(new_strong_beneficiary_authentication['UrlRequest'], 'spec/support-files/test_upload.png')
+      expect(document_upload).to be_true
+    end
+    it "uploads a GIF file to complete a beneficiary strong authentication request" do
+      document_upload = MangoPay::StrongAuthentication.upload(new_strong_beneficiary_authentication['UrlRequest'], 'spec/support-files/test_upload.gif')
+      expect(document_upload).to be_true
+    end
+  end
+
+  describe "UPLOAD USER" do
+    it "uploads a PDF file to complete a user strong authentication request" do
+      document_upload = MangoPay::StrongAuthentication.upload(new_strong_user_authentication['UrlRequest'], 'spec/support-files/test_upload.pdf')
+      expect(document_upload).to be_true
+    end
+    it "uploads a JPG file to complete a user strong authentication request" do
+      document_upload = MangoPay::StrongAuthentication.upload(new_strong_user_authentication['UrlRequest'], 'spec/support-files/test_upload.jpg')
+      expect(document_upload).to be_true
+    end
+    it "uploads a PNG file to complete a user strong authentication request" do
+      document_upload = MangoPay::StrongAuthentication.upload(new_strong_user_authentication['UrlRequest'], 'spec/support-files/test_upload.png')
+      expect(document_upload).to be_true
+    end
+    it "uploads a GIF file to complete a user strong authentication request" do
+      document_upload = MangoPay::StrongAuthentication.upload(new_strong_user_authentication['UrlRequest'], 'spec/support-files/test_upload.gif')
+      expect(document_upload).to be_true
+    end
+  end
+end

data/spec/lib/mangopay/transfer_spec.rb

@@ -0,0 +1,88 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::Transfer, :type => :feature do
+
+    let(:new_payer) {
+        user = MangoPay::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+        contribution = MangoPay::Contribution.create({
+            'Tag' => 'test_contribution',
+            'UserID' => user['ID'],
+            'WalletID' => 0,
+            'Amount' => 10000,
+            'ReturnURL' => 'https://leetchi.com',
+            'BankAccountBIC' => 'AGRIFRPP879'
+            })
+        visit(contribution['PaymentURL'])
+        fill_in('number', :with => '4970100000000154')
+        fill_in('cvv', :with => '123')
+        click_button('paybutton')
+        contribution = MangoPay::Contribution.details(contribution['ID'])
+        while contribution["IsSucceeded"] == false do
+            contribution = MangoPay::Contribution.details(contribution['ID'])
+        end
+        user
+    }
+
+    let(:new_beneficiary) {
+        user = MangoPay::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+        MangoPay::Wallet.create({
+                'Name' => 'test',
+                'Owners' => [ user['ID'] ],
+                'RaisingGoalAmount' => 12000
+                 })
+        user
+    }
+
+    let(:new_transfert) {
+        MangoPay::Transfer.create({
+            'Tag' => 'test transfer',
+            'PayerID' => new_payer['ID'],
+            'BeneficiaryID' => new_beneficiary['ID'],
+            'Amount' => 1000,
+            'PayerWalletID' => 0,
+            'BeneficiaryWalletID' => MangoPay::User.get_wallets(new_beneficiary['ID'])[0]['ID']
+            })
+    }
+
+    let(:new_transfer_refund) {
+        MangoPay::Transfer.refund({
+            'TransferID' => new_transfert['ID'],
+            'UserID' => new_transfert['BeneficiaryID']
+            })
+    }
+
+    describe "CREATE" do
+        it "create a transfer" do
+            expect(new_transfert['ID']).not_to be_nil
+        end
+    end
+
+    describe "GET" do
+        it "gets the transfer" do
+            transfert = MangoPay::Transfer.details(new_transfert['ID'])
+            expect(transfert['ID']).to eq(new_transfert['ID'])
+        end
+    end
+
+    describe "REFUND" do
+        it "create a refund for the transfer" do
+            expect(new_transfer_refund['ID']).not_to be_nil
+        end
+        it "gets a the transfer refund" do
+            transfer_refund = MangoPay::Transfer.get_refund(new_transfer_refund['ID'])
+            expect(transfer_refund['ID']).to eq(new_transfer_refund['ID'])
+        end
+    end
+end

data/spec/lib/mangopay/user_spec.rb

@@ -0,0 +1,124 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::User do
+
+    let(:new_user) {
+        MangoPay::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+
+    let(:new_wallet) {
+        MangoPay::Wallet.create({
+            'Name' => 'test',
+            'Owners' => [ new_user['ID'] ],
+            'RaisingGoalAmount' => 12000
+            })
+    }
+
+    let(:new_strong_authentication) {
+        MangoPay::User.create_strong_authentication(new_user['ID'], {
+            'Tag' => 'test_strong_auth'
+            })
+    }
+
+    describe "CREATE" do
+        it "create a user" do
+            expect(new_user["FirstName"]).to eq('John')
+            expect(new_user["LastName"]).to eq('Doe')
+            expect(new_user["Email"]).to eq('my@email.com')
+            expect(new_user["CanRegisterMeanOfPayment"]).to be_true
+            expect(new_user["ID"]).not_to be_nil
+        end
+    end
+
+    describe "GET" do
+        it "gets the user infos" do
+            user = MangoPay::User.details(new_user["ID"])
+
+            expect(user["FirstName"]).to eq(new_user["FirstName"])
+            expect(user["LastName"]).to eq(new_user["LastName"])
+            expect(user["Email"]).to eq(new_user["Email"])
+            expect(user["ID"]).to eq(new_user["ID"])
+        end
+    end
+
+    describe "UPDATE" do
+        it "update the user infos" do
+            user = MangoPay::User.update(new_user["ID"], {
+                'Tag' => 'test-update',
+                'Email' => 'mynew@email.com',
+                'FirstName' => 'Jack',
+                'LastName' => 'Black',
+                'CanRegisterMeanOfPayment' => false
+                })
+            expect(user["FirstName"]).to eq('Jack')
+            expect(user["LastName"]).to eq('Black')
+            expect(user["Email"]).to eq('mynew@email.com')
+            expect(user["CanRegisterMeanOfPayment"]).to be_false
+            expect(user["ID"]).to eq(new_user["ID"])
+        end
+    end
+
+    describe "GET_WALLETS" do
+        it "get an empty list of wallets" do
+            wallets = MangoPay::User.get_wallets(new_user["ID"])
+            expect(wallets).to be_empty
+        end
+        it "gets a new wallet for the user" do
+            new_wallet
+            wallets = MangoPay::User.get_wallets(new_user['ID'])
+            expect(wallets).not_to be_empty
+            expect(wallets[0]["Owners"][0]).to eq(new_user['ID'])
+        end
+    end
+
+    describe "CARDS" do
+        it "gets the user cards" do
+            cards = MangoPay::User.cards(new_user["ID"])
+            expect(cards).to be_empty
+        end
+    end
+
+    describe "OPERATIONS" do
+        it "gets all the users operations" do
+            operations = MangoPay::User.operations(new_user['ID'])
+            expect(operations).to be_empty
+        end
+        it "gets all the users personal operation" do
+            personal_operations = MangoPay::User.personal_operations(new_user['ID'])
+            expect(personal_operations).to be_empty
+        end
+    end
+
+    describe "STRONG_AUTHENTICATION" do
+        it "creates a new strong authentication request" do
+            expect(new_strong_authentication['ID']).not_to be_nil
+        end
+        it "gets the user strong authentication request" do
+            strong_authentication = MangoPay::User.get_strong_authentication(new_strong_authentication['UserID'])
+            expect(strong_authentication['ID']).to eq(new_strong_authentication['ID'])
+        end
+        it "updates the user strong authentication request" do
+            strong_authentication = MangoPay::User.update_strong_authentication(new_strong_authentication['UserID'], {
+                    'Tag' => 'test_strong_authentication2',
+                    'IsDocumentsTransmitted' => true
+                })
+            expect(strong_authentication['ID']).to eq(new_strong_authentication['ID'])
+            expect(strong_authentication['UserID']).to eq(new_strong_authentication['UserID'])
+            expect(strong_authentication['Tag']).to eq('test_strong_authentication2')
+            expect(strong_authentication['IsDocumentsTransmitted']).to be_true
+        end
+    end
+
+    describe "EXPENSE_SITES" do
+      it "get the expense sites for the given user" do
+        expense_sites = MangoPay::User.expense_sites(new_user['ID'], new_wallet['ID'])
+        expect(expense_sites).to be_kind_of(Array)
+      end
+    end
+end

data/spec/lib/mangopay/wallet_spec.rb

@@ -0,0 +1,81 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::Wallet do
+
+    let(:new_user) {
+        MangoPay::User.create({
+            'Tag' => 'test',
+            'Email' => 'my@email.com',
+            'FirstName' => 'John',
+            'LastName' => 'Doe',
+            'CanRegisterMeanOfPayment' => true
+            })
+    }
+    let(:new_wallet) {
+        MangoPay::Wallet.create({
+            'Name' => 'test',
+            'Owners' => [ new_user['ID'] ],
+            'RaisingGoalAmount' => 12000
+            })
+    }
+
+    describe "CREATE" do
+        it "should create a new wallet" do
+            expect(new_wallet["ID"]).not_to be_nil
+            expect(new_wallet["Name"]).to eq('test')
+            expect(new_wallet["RaisingGoalAmount"]).to eq(12000)
+            expect(new_wallet["CollectedAmount"]).to eq(0)
+            expect(new_wallet["SpentAmount"]).to eq(0)
+        end
+    end
+
+    describe "GET" do
+        it "get the wallet" do
+            wallet = MangoPay::Wallet.details(new_wallet["ID"])
+            expect(wallet['ID']).to eq(new_wallet['ID'])
+            expect(wallet['Name']).to eq(new_wallet['Name'])
+            expect(wallet['Owners']).to eq(new_wallet['Owners'])
+            expect(wallet['RaisingGoalAmount']).to eq(new_wallet['RaisingGoalAmount'])
+        end
+    end
+
+    describe "UPDATE" do
+        it "update the wallet" do
+            wallet = MangoPay::Wallet.update(new_wallet["ID"], {
+                'Name' => 'test_update',
+                'RaisingGoalAmount' => 5000
+                })
+            expect(wallet['ID']).to eq(wallet['ID'])
+            expect(wallet['Name']).to eq('test_update')
+            expect(wallet['RaisingGoalAmount']).to eq(5000)
+        end
+    end
+
+    describe "GET_OWNERS" do
+        it "get the wallet's owners" do
+            wallet = MangoPay::Wallet.get_owners(new_wallet["ID"])
+            expect(wallet[0]['ID']).to eq(new_user['ID'])
+        end
+    end
+
+    describe "GET_CONTRIBUTORS" do
+        it "get the wallet's contributors" do
+            wallet = MangoPay::Wallet.get_contributors(new_wallet["ID"])
+            expect(wallet[0]['ID']).to eq(new_user['ID'])
+        end
+    end
+
+    describe "GET_REFUNDED" do
+        it "get the wallet's refunded" do
+            wallet = MangoPay::Wallet.get_refunded(new_wallet["ID"])
+            expect(wallet[0]['ID']).to eq(new_user['ID'])
+        end
+    end
+
+    describe "OPERATIONS" do
+        it "gets the wallet operations" do
+            operations = MangoPay::Wallet.operations(new_wallet['ID'])
+            expect(operations).to be_kind_of(Array)
+        end
+    end
+end