mangopay 3.0.1 → 3.0.2

data/spec/lib/mangopay/payin_card_web_spec.rb

@@ -0,0 +1,53 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::PayIn::Card::Web, type: :feature do
+  include_context 'payins'
+
+  def check_type_and_status(payin)
+    expect(payin['Type']).to eq('PAYIN')
+    expect(payin['Nature']).to eq('REGULAR')
+    expect(payin['PaymentType']).to eq('CARD')
+    expect(payin['ExecutionType']).to eq('WEB')
+
+    # not SUCCEEDED yet: waiting for processing
+    expect(payin['Status']).to eq('CREATED')
+    expect(payin['ResultCode']).to be_nil
+    expect(payin['ResultMessage']).to be_nil
+    expect(payin['ExecutionDate']).to be_nil
+  end
+  
+  describe 'CREATE' do
+    it 'creates a card web payin' do
+      created = new_payin_card_web
+      expect(created['Id']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payin' do
+      created = new_payin_card_web
+      fetched = MangoPay::PayIn.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      expect(fetched['CreationDate']).to eq(created['CreationDate'])
+      expect(fetched['CreditedFunds']).to eq(created['CreditedFunds'])
+      expect(fetched['CreditedWalletId']).to eq(created['CreditedWalletId'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
+    end
+  end
+
+  describe 'REFUND' do
+    it 'refunds a payin' do
+      payin = new_payin_card_web
+      expect {
+        MangoPay::PayIn.refund(payin['Id'], {AuthorId: payin['AuthorId']})
+      }.to raise_error { |err|
+        err.should be_a MangoPay::ResponseError
+        err.type.should eq 'other'
+        err.message.should eq "Impossible to refund the transaction, can't have negative amount."
+      }
+    end
+  end
+
+end

data/spec/lib/mangopay/payout_bankwire_spec.rb

@@ -0,0 +1,56 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::PayOut::BankWire, type: :feature do
+  include_context 'bank_accounts'
+  include_context 'payins'
+  include_context 'payouts'
+
+  def check_type_and_status(payout)
+    expect(payout['Type']).to eq('PAYOUT')
+    expect(payout['Nature']).to eq('REGULAR')
+    expect(payout['PaymentType']).to eq('BANK_WIRE')
+
+    # linked to correct bank account
+    expect(payout['BankAccountId']).to eq(new_bank_account['Id'])
+
+    # not SUCCEEDED yet: waiting for processing
+    expect(payout['Status']).to eq('CREATED')
+    expect(payout['ResultCode']).to be_nil
+    expect(payout['ResultMessage']).to be_nil
+    expect(payout['ExecutionDate']).to be_nil
+  end
+
+  describe 'CREATE' do
+
+    it 'creates a bank wire payout' do
+      payin = new_payin_card_direct # this payin is successfull so payout may happen
+      payout = create_new_payout_bankwire(payin)
+      expect(payout['Id']).not_to be_nil
+      check_type_and_status(payout)
+      expect(payout['DebitedWalletId']).to eq(payin['CreditedWalletId'])
+    end
+
+    it 'fails if not enough money' do
+      payin = new_payin_card_web # this payin is NOT processed yet so payout may NOT happen
+      expect {
+        create_new_payout_bankwire(payin)
+      }.to raise_error { |err|
+        err.should be_a MangoPay::ResponseError
+        err.type.should eq 'other'
+        err.message.should eq 'The amount you wish to spend must be smaller than the amount left in your collection.'
+      }
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payout' do
+      created = new_payout_bankwire
+      fetched = MangoPay::PayOut.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      expect(fetched['CreationDate']).to eq(created['CreationDate'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
+    end
+  end
+
+end

data/spec/lib/mangopay/shared_resources.rb

@@ -1,4 +1,8 @@
+###############################################
 shared_context 'clients' do
+###############################################
+
+  require 'securerandom'
 
   let(:client_id) {
     SecureRandom.hex(10)
@@ -25,11 +29,13 @@ shared_context 'clients' do
   }
 end
 
+###############################################
 shared_context 'users' do
+###############################################
 
   let(:new_natural_user) {
     MangoPay::NaturalUser.create({
-      Tag: 'test',
+      Tag: 'Test natural user',
       Email: 'my@email.com',
       FirstName: 'John',
       LastName: 'Doe',
@@ -62,132 +68,167 @@ shared_context 'users' do
   }
 end
 
+###############################################
 shared_context 'wallets' do
+###############################################
+  include_context 'users'
 
-  let(:new_wallet) {
+  let(:new_wallet) { create_new_wallet(new_natural_user) }
+  let(:new_wallet_legal) { create_new_wallet(new_legal_user) }
+  def create_new_wallet(user)
     MangoPay::Wallet.create({
-      Owners: [new_natural_user['Id']],
+      Owners: [user['Id']],
       Description: 'A test wallet',
       Currency: 'EUR',
-      Tag: 'Test Time'
+      Tag: 'Test wallet'
     })
-  }
+  end
+
+  def wallets_check_amounts(wlt1, amnt1, wlt2 = nil, amnt2 = nil)
+    expect(wlt1['Balance']['Amount']).to eq amnt1
+    expect(wlt2['Balance']['Amount']).to eq amnt2 if wlt2
+  end
+
+  def wallets_reload_and_check_amounts(wlt1, amnt1, wlt2 = nil, amnt2 = nil)
+    wlt1 = MangoPay::Wallet::fetch(wlt1['Id'])
+    wlt2 = MangoPay::Wallet::fetch(wlt2['Id']) if wlt2
+    wallets_check_amounts(wlt1, amnt1, wlt2, amnt2)
+  end
 end
 
-shared_context 'bank_details' do
+###############################################
+shared_context 'bank_accounts' do
+###############################################
+  include_context 'users'
 
-  let(:new_iban_bank_detail) {
+  let(:new_bank_account) {
     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'
+      Tag: 'Test bank account'
     })
   }
 end
 
-shared_context 'payin_card_web' do
+###############################################
+shared_context 'payins' do
+###############################################
+  include_context 'users'
+  include_context 'wallets'
+
+  ###############################################
+  # card/web
+  ###############################################
+
   let(:new_payin_card_web) {
-    card = MangoPay::PayIn::Card::Web.create({
+    MangoPay::PayIn::Card::Web.create({
       AuthorId: new_natural_user['Id'],
       CreditedUserId: new_wallet['Owners'][0],
+      CreditedWalletId: new_wallet['Id'],
       DebitedFunds: { Currency: 'EUR', Amount: 1000 },
       Fees: { Currency: 'EUR', Amount: 0 },
-      CreditedWalletId: new_wallet['Id'],
       CardType: 'CB_VISA_MASTERCARD',
       ReturnURL: MangoPay.configuration.root_url,
       Culture: 'FR',
       Tag: 'Test PayIn/Card/Web'
     })
-#    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 'payout_bankwire' do
-  let(:new_payout_bankwire){
-    MangoPay::PayOut::BankWire.create({
-      AuthorId: new_payin_card_web['CreditedUserId'],
-      DebitedFunds: { Currency: 'EUR', Amount: 500 },
-      Fees: { Currency: 'EUR', Amount: 0 },
-      DebitedWalletId: new_payin_card_web['CreditedWalletId'],
-      BankAccountId: new_iban_bank_detail['Id'],
-      Communication: 'This is a test',
-      Tag: 'Test Bank Wire'
-    })
-  }
-end
+  ###############################################
+  # card/direct
+  ###############################################
 
-shared_context 'transfer' do
-  let(:credited_wallet) {
-    MangoPay::Wallet.create({
-      Owners: [new_natural_user['Id']],
-      Description: 'A test wallet',
+  let(:new_card_registration) {
+    MangoPay::CardRegistration.create({
+      UserId: new_natural_user['Id'],
       Currency: 'EUR',
-      Tag: 'Test Time'
+      Tag: 'Test Card Registration'
     })
   }
 
-  let(:debited_wallet) {
-    MangoPay::Wallet.create({
-      Owners: [new_legal_user['Id']],
-      Description: 'A test wallet',
-      Currency: 'EUR',
-      Tag: 'Test Time'
+  let(:new_card_registration_completed) {
+    # 1st step: create
+    cardreg = new_card_registration
+
+    # 2nd step: tokenize by payline (fills-in RegistrationData)
+    data = {
+      data: cardreg['PreregistrationData'],
+      accessKeyRef: cardreg['AccessKey'],
+      cardNumber: 4970101122334406,
+      cardExpirationDate: 1214,
+      cardCvx: 123}
+    res = Net::HTTP.post_form(URI(cardreg['CardRegistrationURL']), data)
+    raise Exception, [res, res.body] unless (res.is_a?(Net::HTTPOK) && res.body.start_with?('data='))
+    cardreg['RegistrationData'] = res.body
+
+    # 3rd step: update (fills-in CardId) and return it
+    MangoPay::CardRegistration.update(cardreg['Id'], {
+      RegistrationData: cardreg['RegistrationData']
     })
   }
 
-  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 },
+  let(:new_payin_card_direct) { create_new_payin_card_direct(new_wallet) }
+  def create_new_payin_card_direct(to_wallet, amnt = 1000)
+    cardreg = new_card_registration_completed
+    MangoPay::PayIn::Card::Direct.create({
+      AuthorId: new_natural_user['Id'],
+      CreditedUserId: to_wallet['Owners'][0],
+      CreditedWalletId: to_wallet['Id'],
+      DebitedFunds: { Currency: 'EUR', Amount: amnt },
       Fees: { Currency: 'EUR', Amount: 0 },
-      CreditedWalletId: debited_wallet['Id'],
       CardType: 'CB_VISA_MASTERCARD',
-      ReturnURL: MangoPay.configuration.root_url,
-      Culture: 'FR',
-      Tag: 'Test PayIn/Card/Web'
+      CardId: cardreg['CardId'],
+      SecureModeReturnURL: 'http://test.com',
+      Tag: 'Test PayIn/Card/Direct'
     })
-#    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
 
-  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
 
-shared_context 'card_registration' do
-  let(:new_card_registration) {
-    MangoPay::CardRegistration.create({
-      UserId: new_natural_user['Id'],
-      Currency: 'EUR',
-      Tag: 'Test Card Registration'
+###############################################
+shared_context 'payouts' do
+###############################################
+  include_context 'bank_accounts'
+
+  let(:new_payout_bankwire) { create_new_payout_bankwire(new_payin_card_direct) }
+  def create_new_payout_bankwire(payin, amnt = 500)
+    MangoPay::PayOut::BankWire.create({
+      AuthorId: payin['CreditedUserId'],
+      DebitedWalletId: payin['CreditedWalletId'],
+      DebitedFunds: { Currency: 'EUR', Amount: amnt },
+      Fees: { Currency: 'EUR', Amount: 0 },
+      BankAccountId: new_bank_account['Id'],
+      Communication: 'This is a test',
+      Tag: 'Test PayOut/Bank/Wire'
     })
+  end
+end
+
+###############################################
+shared_context 'transfers' do
+###############################################
+  include_context 'users'
+  include_context 'wallets'
+  include_context 'payins'
+
+  let(:new_transfer) {
+    wlt1 = new_wallet
+    wlt2 = new_wallet_legal
+    create_new_payin_card_direct(wlt1, 1000) # feed wlt1 with money
+    create_new_transfer(wlt1, wlt2, 500) # transfer wlt1 => wlt2
   }
+  def create_new_transfer(from_wallet, to_wallet, amnt = 500)
+    MangoPay::Transfer.create({
+      AuthorId: from_wallet['Owners'][0],
+      DebitedWalletId: from_wallet['Id'],
+      CreditedUserId: to_wallet['Owners'][0],
+      CreditedWalletId: to_wallet['Id'],
+      DebitedFunds: { Currency: 'EUR', Amount: amnt},
+      Fees: { Currency: 'EUR', Amout: 0},
+      Tag: 'Test transfer'
+    })
+  end
 end

data/spec/lib/mangopay/transaction_spec.rb

@@ -1,14 +1,60 @@
 require_relative '../../spec_helper'
 
 describe MangoPay::Transaction do
-  include_context 'users'
   include_context 'wallets'
+  include_context 'payins'
+  include_context 'payouts'
 
   describe 'FETCH' do
-    it 'fetches the an empty list of transactions' do
+
+    it 'fetches empty list of transactions if no transactions done' do
       transactions = MangoPay::Transaction.fetch(new_wallet['Id'])
       expect(transactions).to be_kind_of(Array)
       expect(transactions).to be_empty
     end
+
+    it 'fetches list with single transaction after payin done' do
+      payin = new_payin_card_direct
+      transactions = MangoPay::Transaction.fetch(new_wallet['Id'])
+      expect(transactions).to be_kind_of(Array)
+      expect(transactions.count).to eq 1
+      expect(transactions.first['Id']).to eq payin['Id']
+    end
+
+    it 'fetches list with two transactions after payin and payout done' do
+      payin = new_payin_card_direct
+      payout = create_new_payout_bankwire(payin)
+      transactions = MangoPay::Transaction.fetch(new_wallet['Id'])
+      expect(transactions).to be_kind_of(Array)
+      expect(transactions.count).to eq 2
+      expect(transactions[0]['Id']).to eq payout['Id'] # last on top, so payout is before payin
+      expect(transactions[1]['Id']).to eq payin['Id']
+    end
+
+    it 'accepts filtering params' do
+      payin = new_payin_card_direct
+      payout = create_new_payout_bankwire(payin)
+      wallet_id = new_wallet['Id']
+
+      by_nature_reg = MangoPay::Transaction.fetch(wallet_id, {'Nature' => 'REGULAR'})
+      by_nature_ref = MangoPay::Transaction.fetch(wallet_id, {'Nature' => 'REFUND'})
+      expect(by_nature_reg.count).to eq 2
+      expect(by_nature_ref.count).to eq 0
+
+      by_type_pyin  = MangoPay::Transaction.fetch(wallet_id, {'Type' => 'PAYIN'})
+      by_type_pyout = MangoPay::Transaction.fetch(wallet_id, {'Type' => 'PAYOUT'})
+      expect(by_type_pyin.count).to eq 1
+      expect(by_type_pyout.count).to eq 1
+      expect(by_type_pyin.first['Id']).to eq payin['Id']
+      expect(by_type_pyout.first['Id']).to eq payout['Id']
+
+      by_dir_cred = MangoPay::Transaction.fetch(wallet_id, {'Direction' => 'CREDIT'})
+      by_dir_debt = MangoPay::Transaction.fetch(wallet_id, {'Direction' => 'DEBIT'})
+      expect(by_dir_cred.count).to eq 1
+      expect(by_dir_debt.count).to eq 1
+      expect(by_dir_cred.first['Id']).to eq payin['Id']
+      expect(by_dir_debt.first['Id']).to eq payout['Id']
+    end
+
   end
 end

data/spec/lib/mangopay/transfer_spec.rb

@@ -1,35 +1,71 @@
 require_relative '../../spec_helper'
 
 describe MangoPay::Transfer, type: :feature do
-  include_context 'users'
   include_context 'wallets'
-  include_context 'transfer'
+  include_context 'payins'
+  include_context 'transfers'
+
+  def check_type_and_status(trans)
+    expect(trans['Type']).to eq('TRANSFER')
+    expect(trans['Nature']).to eq('REGULAR')
+
+    # SUCCEEDED
+    expect(trans['Status']).to eq('SUCCEEDED')
+    expect(trans['ResultCode']).to eq('000000')
+    expect(trans['ResultMessage']).to eq('Success')
+    expect(trans['ExecutionDate']).to be > 0
+  end
 
   describe 'CREATE' do
     it 'creates a new Transfer' do
-      expect(new_transfer['Id']).not_to be_nil
-      #expect(new_transfer['Status']).to eq('SUCCEEDED') # cannot test yet
-      expect(new_transfer['Status']).to eq('FAILED')
+      created = new_transfer
+      expect(created['Id']).not_to be_nil
+      check_type_and_status(created)
     end
   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') # cannot test yet
-      expect(new_transfer['Status']).to eq('FAILED')
+      created = new_transfer
+      fetched = MangoPay::Transfer.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
     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') # cannot test yet
-      expect(transfer_refund['Status']).to be_nil
+      trans = new_transfer
+      refund = MangoPay::Transfer.refund(trans['Id'], {AuthorId: trans['AuthorId']})
+      expect(refund['Id']).not_to be_nil
+      expect(refund['Status']).to eq('SUCCEEDED')
+      expect(refund['Type']).to eq('TRANSFER')
+      expect(refund['Nature']).to eq('REFUND')
+      expect(refund['InitialTransactionType']).to eq('TRANSFER')
+      expect(refund['InitialTransactionId']).to eq(trans['Id'])
+      expect(refund['DebitedWalletId']).to eq(trans['CreditedWalletId'])
+      expect(refund['CreditedWalletId']).to eq(trans['DebitedWalletId'])
+    end
+  end
+
+  describe 'CASH FLOW' do
+    it 'changes balances correctly' do
+      wlt1 = new_wallet
+      wlt2 = new_wallet_legal
+      wallets_check_amounts(wlt1, 0, wlt2, 0)
+
+      # payin: feed wlt1 with money
+      create_new_payin_card_direct(wlt1, 1000)
+      wallets_reload_and_check_amounts(wlt1, 1000, wlt2, 0)
+
+      # trnasfer wlt1 => wlt2
+      trans = create_new_transfer(wlt1, wlt2, 600)
+      wallets_reload_and_check_amounts(wlt1, 400, wlt2, 600)
+
+      # refund the trnasfer
+      refund = MangoPay::Transfer.refund(trans['Id'], {AuthorId: trans['AuthorId']})
+      wallets_reload_and_check_amounts(wlt1, 1000, wlt2, 0)
     end
   end
 end