mangopay 2.0.0 → 3.0.0

data/mangopay.gemspec

@@ -0,0 +1,33 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'mangopay/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'mangopay'
+  s.version     = MangoPay::VERSION
+  s.summary     = "Ruby bindings for the version 2 of the MangoPay API"
+  s.description = <<-EOF
+  The mangopay Gem makes interacting with MangoPay Services much easier.
+  For any questions regarding the use of MangoPay's Services feel free to contact us at http://www.mangopay.com/contact-us/
+  You can find more documentation about MangoPay Services at http://www.mangopay.com/
+  EOF
+  s.authors     = ['Geoffroy Lorieux']
+  s.email       = 'it-support@mangopay.com'
+  s.homepage    = 'http://www.mangopay.com/'
+  s.license     = 'MIT'
+
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.add_dependency('multi_json', '~> 1.7.7')
+
+  s.add_development_dependency('rake', '~> 10.1.0')
+  s.add_development_dependency('rspec', '~> 2.14.1')
+  s.add_development_dependency('capybara', '~> 2.1.0')
+  s.add_development_dependency('capybara-webkit', '~> 1.0.0')
+  s.add_development_dependency('rails', '~> 4.0.0')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/spec/lib/mangopay/bank_account_spec.rb

@@ -0,0 +1,26 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::BankAccount do
+  include_context 'users'
+  include_context 'bank_details'
+
+  describe 'CREATE' do
+    it 'creates a new bank detail' do
+      expect(new_iban_bank_detail['Id']).not_to be_nil
+    end
+  end
+
+  describe 'FETCH' do
+
+    it 'fetches all the bank details' do
+      bank_details = MangoPay::BankAccount.fetch(new_iban_bank_detail['UserId'])
+      expect(bank_details).to be_kind_of(Array)
+      expect(bank_details[0]['Id']).to eq(new_iban_bank_detail['Id'])
+    end
+
+    it 'fetches one bank detail' do
+      bank_detail = MangoPay::BankAccount.fetch(new_iban_bank_detail['UserId'], new_iban_bank_detail['Id'])
+      expect(bank_detail['Id']).to eq(new_iban_bank_detail['Id'])
+    end
+  end
+end

data/spec/lib/mangopay/client_spec.rb

@@ -0,0 +1,27 @@
+require_relative '../../spec_helper'
+require 'securerandom'
+
+describe MangoPay::Client do
+  include_context 'clients'
+
+  describe 'CREATE' do
+    it 'creates a new client' do
+      expect(new_client['ClientId']).to eq(client_id)
+      expect(new_client['Email']).not_to be_nil
+      expect(new_client['Passphrase']).not_to be_nil
+    end
+
+    it 'refuses the client id' do
+      expect(wrong_client['errors']).not_to be_nil
+    end
+
+    it "ClientId_already_exist" do
+      existing_client = MangoPay::Client.create({
+        'ClientId' => new_client['ClientId'],
+        'Name' => 'What a nice name'
+      })
+      expect(existing_client['Type']).to eq('ClientId_already_exist')
+      expect(existing_client['Message']).to eq('A partner with this ClientId already exist')
+    end
+  end
+end

data/spec/lib/mangopay/payin_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::PayIn::Card::Web, type: :feature do
+  include_context 'users'
+  include_context 'wallets'
+  include_context 'cards'
+
+  describe 'CREATE' do
+    it 'creates a card' do
+      expect(new_web_card['Id']).not_to be_nil
+      expect(new_web_card['Status']).to eq('SUCCEEDED')
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payin' do
+      payin = MangoPay::PayIn.fetch(new_web_card['Id'])
+      expect(payin['Id']).to eq(new_web_card['Id'])
+    end
+  end
+
+  describe 'REFUND' do
+    it 'refunds a payin' do
+      payin_refund = MangoPay::PayIn.refund(new_web_card['Id'], {
+        AuthorId: new_web_card['AuthorId']
+      })
+      expect(payin_refund['Id']).not_to be_nil
+      expect(payin_refund['Status']).to eq('SUCCEEDED')
+    end
+  end
+end

data/spec/lib/mangopay/payout_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::PayOut::BankWire, type: :feature do
+  include_context 'users'
+  include_context 'wallets'
+  include_context 'bank_details'
+  include_context 'cards'
+  include_context 'bank_wires'
+
+  describe 'CREATE' do
+    it 'creates a bank wire payout' do
+      expect(new_bank_wire['Id']).not_to be_nil
+      expect(new_bank_wire['Status']).to eq('CREATED')
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payout' do
+      bank_wire = MangoPay::PayOut.fetch(new_bank_wire['Id'])
+      expect(bank_wire['Id']).to eq(new_bank_wire['Id'])
+      expect(new_bank_wire['Status']).to eq('CREATED')
+    end
+  end
+end

data/spec/lib/mangopay/shared_resources.rb

@@ -0,0 +1,183 @@
+shared_context 'clients' do
+
+  let(:client_id) {
+    SecureRandom.hex(10)
+  }
+
+  let(:wrong_client_id) {
+   SecureRandom.hex(20)
+  }
+
+  let(:wrong_client) {
+    MangoPay::Client.create({
+      'ClientID' => wrong_client_id,
+      'Name' => 'What a nice name',
+      'Email' => 'clientemail@email.com'
+    })
+  }
+
+  let(:new_client) {
+    MangoPay::Client.create({
+      'ClientID' => client_id,
+      'Name' => 'What a nice name',
+      'Email' => 'clientemail@email.com'
+    })
+  }
+end
+
+shared_context 'users' do
+
+  let(:new_natural_user) {
+    MangoPay::NaturalUser.create({
+      Tag: 'test',
+      Email: 'my@email.com',
+      FirstName: 'John',
+      LastName: 'Doe',
+      Address: 'Here',
+      Birthday: '',
+      Birthplace: 'Paris',
+      Nationality: 'FR',
+      CountryOfResidence: 'FR',
+      Occupation: 'Worker',
+      IncomeRange: 1
+    })
+  }
+
+  let(:new_legal_user) {
+    MangoPay::LegalUser.create({
+      Name: 'Super',
+      LegalPersonType: 'BUSINESS',
+      HeadquartersAddress: 'Here',
+      LegalRepresentativeFirstName: 'John',
+      LegalRepresentativeLastName: 'Doe',
+      LegalRepresentativeAdress: 'Here',
+      LegalRepresentativeEmail: 'john@doe.com',
+      LegalRepresentativeBirthday: '',
+      LegalRepresentativeNationality: 'FR',
+      LegalRepresentativeCountryOfResidence: 'FR',
+      Statute: '',
+      ProofOfRegistration: '',
+      ShareholderDeclaration: ''
+    })
+  }
+end
+
+shared_context 'wallets' do
+
+  let(:new_wallet) {
+    MangoPay::Wallet.create({
+      Owners: [new_natural_user['Id']],
+      Description: 'A test wallet',
+      Currency: 'EUR',
+      Tag: 'Test Time'
+    })
+  }
+end
+
+shared_context 'bank_details' do
+
+  let(:new_iban_bank_detail) {
+    MangoPay::BankAccount.create(new_natural_user['Id'], {
+      Type: 'IBAN',
+      OwnerName: 'John',
+      OwnerAddress: 'Here',
+      IBAN: 'FR76 1790 6000 3200 0833 5232 973',
+      BIC: 'AGRIFRPP879',
+      Tag: 'Test Time'
+    })
+  }
+end
+
+shared_context 'cards' do
+  let(:new_web_card) {
+    card = MangoPay::PayIn::Card::Web.create({
+      AuthorId: new_natural_user['Id'],
+      CreditedUserId: new_wallet['Owners'][0],
+      DebitedFunds: { Currency: 'EUR', Amount: 1000 },
+      Fees: { Currency: 'EUR', Amount: 0 },
+      CreditedWalletId: new_wallet['Id'],
+      ReturnURL: MangoPay.configuration.root_url,
+      CardType: 'CB_VISA_MASTERCARD',
+      Culture: 'FR',
+      Tag: 'Test Card'
+    })
+    visit(card['RedirectURL'])
+    fill_in('number', with: '4970100000000154')
+    fill_in('cvv', with: '123')
+    click_button('paybutton')
+    card = MangoPay::PayIn.fetch(card['Id'])
+    while card["Status"] == 'CREATED' do
+      card = MangoPay::PayIn.fetch(card['Id'])
+    end
+    card
+  }
+end
+
+shared_context 'bank_wires' do
+  let(:new_bank_wire){
+    MangoPay::PayOut::BankWire.create({
+      AuthorId: new_web_card['CreditedUserId'],
+      DebitedFunds: { Currency: 'EUR', Amount: 500 },
+      Fees: { Currency: 'EUR', Amount: 0 },
+      DebitedWalletId: new_web_card['CreditedWalletId'],
+      BankAccountId: new_iban_bank_detail['Id'],
+      Communication: 'This is a test',
+      Tag: 'Test Bank Wire'
+    })
+  }
+end
+
+shared_context 'transfer' do
+  let(:credited_wallet) {
+    MangoPay::Wallet.create({
+      Owners: [new_natural_user['Id']],
+      Description: 'A test wallet',
+      Currency: 'EUR',
+      Tag: 'Test Time'
+    })
+  }
+
+  let(:debited_wallet) {
+    MangoPay::Wallet.create({
+      Owners: [new_legal_user['Id']],
+      Description: 'A test wallet',
+      Currency: 'EUR',
+      Tag: 'Test Time'
+    })
+  }
+
+  let(:web_card_contribution) {
+    card = MangoPay::PayIn::Card::Web.create({
+      AuthorId: debited_wallet['Owners'][0],
+      CreditedUserId: debited_wallet['Owners'][0],
+      DebitedFunds: { Currency: 'EUR', Amount: 1000 },
+      Fees: { Currency: 'EUR', Amount: 0 },
+      CreditedWalletId: debited_wallet['Id'],
+      ReturnURL: MangoPay.configuration.root_url,
+      CardType: 'CB_VISA_MASTERCARD',
+      Culture: 'FR',
+      Tag: 'Test Card'
+    })
+    visit(card['RedirectURL'])
+    fill_in('number', with: '4970100000000154')
+    fill_in('cvv', with: '123')
+    click_button('paybutton')
+    card = MangoPay::PayIn.fetch(card['Id'])
+    while card["Status"] == 'CREATED' do
+      card = MangoPay::PayIn.fetch(card['Id'])
+    end
+    card
+  }
+
+  let(:new_transfer) {
+    MangoPay::Transfer.create({
+      AuthorId: web_card_contribution['CreditedUserId'],
+      CreditedUserId: credited_wallet['Owners'][0],
+      DebitedFunds: { Currency: 'EUR', Amount: 500},
+      Fees: { Currency: 'EUR', Amout: 0},
+      DebitedWalletId: web_card_contribution['CreditedWalletId'],
+      CreditedWalletId: credited_wallet['Id'],
+      Tag: 'Test Transfer'
+    })
+  }
+end

data/spec/lib/mangopay/transaction_spec.rb

@@ -0,0 +1,14 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::Transaction do
+  include_context 'users'
+  include_context 'wallets'
+
+  describe 'FETCH' do
+    it 'fetches the an empty list of transactions' do
+      transactions = MangoPay::Transaction.fetch(new_wallet['Id'])
+      expect(transactions).to be_kind_of(Array)
+      expect(transactions).to be_empty
+    end
+  end
+end

data/spec/lib/mangopay/transfer_spec.rb

@@ -1,88 +1,32 @@
 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
+describe MangoPay::Transfer, type: :feature do
+  include_context 'users'
+  include_context 'wallets'
+  include_context 'transfer'
+
+  describe 'CREATE' do
+    it 'creates a new Transfer' do
+      expect(new_transfer['Id']).not_to be_nil
+      expect(new_transfer['Status']).to eq('SUCCEEDED')
     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
+  describe 'FETCH' do
+    it 'fetches a Transfer' do
+      transfer = MangoPay::Transfer.fetch(new_transfer['Id'])
+      expect(transfer['Id']).to eq(new_transfer['Id'])
+      expect(new_transfer['Status']).to eq('SUCCEEDED')
     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
+
+  describe 'REFUND' do
+    it 'refunds a transfer' do
+      transfer_refund = MangoPay::Transfer.refund(new_transfer['Id'], {
+        AuthorId: new_transfer['AuthorId']
+      })
+      expect(transfer_refund['Id']).not_to be_nil
+      expect(transfer_refund['Status']).to eq('SUCCEEDED')
     end
+  end
 end