mangopay 3.0.11 → 3.0.12

data/spec/{lib/mangopay → mangopay}/client_spec.rb

@@ -1,5 +1,3 @@
-require_relative '../../spec_helper'
-
 describe MangoPay::Client do
   include_context 'clients'
 
@@ -12,8 +10,8 @@ describe MangoPay::Client do
 
     it 'refuses the client id' do
       expect { wrong_client['errors'] }.to raise_error { |err|
-        err.should be_a MangoPay::ResponseError
-        err.type.should eq 'param_error'
+        expect(err).to be_a MangoPay::ResponseError
+        expect(err.type).to eq 'param_error'
       }
     end
 

data/spec/{lib/mangopay → mangopay}/configuration_spec.rb

@@ -1,20 +1,18 @@
-require_relative '../../spec_helper'
-
-describe MangoPay::Configuration do
-
-  it 'fails when calling with wrong client credentials' do
-    expect {
-      c = MangoPay.configuration
-      c.client_id = 'test_asd'
-      c.client_passphrase = '00000'
-      MangoPay::User.fetch()
-    }.to raise_error(MangoPay::ResponseError)
-  end
-
-  it 'goes ok when calling with correct client credentials' do
-    reset_mangopay_configuration
-    users = MangoPay::User.fetch()
-    expect(users).to be_kind_of(Array)
-  end
-
-end
+describe MangoPay::Configuration do
+
+  it 'fails when calling with wrong client credentials' do
+    expect {
+      c = MangoPay.configuration
+      c.client_id = 'test_asd'
+      c.client_passphrase = '00000'
+      MangoPay::User.fetch()
+    }.to raise_error(MangoPay::ResponseError)
+  end
+
+  it 'goes ok when calling with correct client credentials' do
+    reset_mangopay_configuration
+    users = MangoPay::User.fetch()
+    expect(users).to be_kind_of(Array)
+  end
+
+end

data/spec/{lib/mangopay → mangopay}/event_spec.rb

@@ -1,33 +1,31 @@
-require_relative '../../spec_helper'
-
-describe MangoPay::Event do
-
-  include_context 'payins'
-  include_context 'payouts'
-
-  describe 'FETCH' do
-
-    it 'accepts filtering params' do
-
-      # let's have at least 2 events
-      payin = new_payin_card_direct
-      payout = create_new_payout_bankwire(payin)
-
-      # get all
-      events = MangoPay::Event.fetch()
-      expect(events).to be_kind_of(Array)
-      expect(events.count).to be >= 2
-
-      # only one per page
-      events = MangoPay::Event.fetch({'per_page' => 1})
-      expect(events).to be_kind_of(Array)
-      expect(events.count).to eq 1
-
-      # filter by date
-      events = MangoPay::Event.fetch({'AfterDate' => payin['CreationDate'], 'BeforeDate' => payin['CreationDate']})
-      expect(events).to be_kind_of(Array)
-      expect(events.count).to be >= 1
-      expect(events.count {|e| e['ResourceId'] == payin['Id']}).to be >= 1
-    end
-  end
-end
+describe MangoPay::Event do
+
+  include_context 'payins'
+  include_context 'payouts'
+
+  describe 'FETCH' do
+
+    it 'accepts filtering params' do
+
+      # let's have at least 2 events
+      payin = new_payin_card_direct
+      create_new_payout_bankwire(payin)
+
+      # get all
+      events = MangoPay::Event.fetch()
+      expect(events).to be_kind_of(Array)
+      expect(events.count).to be >= 2
+
+      # only one per page
+      events = MangoPay::Event.fetch({'per_page' => 1})
+      expect(events).to be_kind_of(Array)
+      expect(events.count).to eq 1
+
+      # filter by date
+      events = MangoPay::Event.fetch({'AfterDate' => payin['CreationDate'], 'BeforeDate' => payin['CreationDate']})
+      expect(events).to be_kind_of(Array)
+      expect(events.count).to be >= 1
+      expect(events.count { |e| e['ResourceId'] == payin['Id'] }).to be >= 1
+    end
+  end
+end

data/spec/{lib/mangopay → mangopay}/fetch_filters_spec.rb

@@ -1,5 +1,3 @@
-require_relative '../../spec_helper'
-
 describe 'FETCH WITH FILTERS' do
   include_context 'users'
   include_context 'bank_accounts'

data/spec/{lib/mangopay → mangopay}/hook_spec.rb

@@ -1,5 +1,3 @@
-require_relative '../../spec_helper'
-
 describe MangoPay::Hook do
   include_context 'hooks'
 

data/spec/{lib/mangopay → mangopay}/kyc_document_spec.rb

@@ -1,60 +1,58 @@
-require_relative '../../spec_helper'
-
-describe MangoPay::KycDocument do
-  include_context 'kyc_documents'
-
-  describe 'CREATE' do
-    it 'creates a document' do
-      expect(new_document['Id']).to_not be_nil
-      expect(new_document['Type']).to eq('IDENTITY_PROOF')
-      expect(new_document['Status']).to eq('CREATED')
-      expect(new_document['RefusedReasonType']).to be_nil
-      expect(new_document['RefusedReasonMessage']).to be_nil
-    end
-  end
-
-  describe 'UPDATE' do
-    it 'updates a document' do
-      updated_document = MangoPay::KycDocument.update(new_natural_user['Id'], new_document['Id'], {
-        Status: 'VALIDATION_ASKED'
-      })
-      expect(updated_document['Id']).to eq(new_document['Id'])
-      expect(updated_document['Status']).to eq('VALIDATION_ASKED')
-    end
-  end
-
-  describe 'FETCH' do
-    it 'fetches a document' do
-      document = MangoPay::KycDocument.fetch(new_natural_user['Id'], new_document['Id'])
-      expect(document['Id']).to eq(new_document['Id'])
-    end
-  end
-
-  describe 'CREATE PAGE' do
-
-    def create_page(file)
-      MangoPay::KycDocument.create_page(new_natural_user['Id'], new_document['Id'], file)
-    end
-
-    it 'accepts File instance' do
-      file = File.open(__FILE__)
-      ret = create_page(file)
-      expect(ret).to be_nil
-    end
-
-    it 'accepts base64-encoded string' do
-      file = Base64.encode64('any file content...')
-      ret = create_page(file)
-      expect(ret).to be_nil
-    end
-
-    it 'fails when input string is not base64-encoded' do
-      file = 'any file content...'
-      expect { create_page(file) }.to raise_error { |err|
-        err.should be_a MangoPay::ResponseError
-        err.code.should eq '400'
-        err.type.should eq 'param_error'
-      }
-    end
-  end
-end
+describe MangoPay::KycDocument do
+  include_context 'kyc_documents'
+
+  describe 'CREATE' do
+    it 'creates a document' do
+      expect(new_document['Id']).to_not be_nil
+      expect(new_document['Type']).to eq('IDENTITY_PROOF')
+      expect(new_document['Status']).to eq('CREATED')
+      expect(new_document['RefusedReasonType']).to be_nil
+      expect(new_document['RefusedReasonMessage']).to be_nil
+    end
+  end
+
+  describe 'UPDATE' do
+    it 'updates a document' do
+      updated_document = MangoPay::KycDocument.update(new_natural_user['Id'], new_document['Id'], {
+        Status: 'VALIDATION_ASKED'
+      })
+      expect(updated_document['Id']).to eq(new_document['Id'])
+      expect(updated_document['Status']).to eq('VALIDATION_ASKED')
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a document' do
+      document = MangoPay::KycDocument.fetch(new_natural_user['Id'], new_document['Id'])
+      expect(document['Id']).to eq(new_document['Id'])
+    end
+  end
+
+  describe 'CREATE PAGE' do
+
+    def create_page(file)
+      MangoPay::KycDocument.create_page(new_natural_user['Id'], new_document['Id'], file)
+    end
+
+    it 'accepts File instance' do
+      file = File.open(__FILE__)
+      ret = create_page(file)
+      expect(ret).to be_nil
+    end
+
+    it 'accepts base64-encoded string' do
+      file = Base64.encode64('any file content...')
+      ret = create_page(file)
+      expect(ret).to be_nil
+    end
+
+    it 'fails when input string is not base64-encoded' do
+      file = 'any file content...'
+      expect { create_page(file) }.to raise_error { |err|
+        expect(err).to be_a MangoPay::ResponseError
+        expect(err.code).to eq '400'
+        expect(err.type).to eq 'param_error'
+      }
+    end
+  end
+end

data/spec/{lib/mangopay → mangopay}/payin_bankwire_direct_spec.rb

@@ -1,5 +1,3 @@
-require_relative '../../spec_helper'
-
 describe MangoPay::PayIn::BankWire::Direct, type: :feature do
   include_context 'wallets'
   include_context 'payins'

data/spec/{lib/mangopay → mangopay}/payin_card_direct_spec.rb

@@ -1,5 +1,3 @@
-require_relative '../../spec_helper'
-
 describe MangoPay::PayIn::Card::Direct, type: :feature do
   include_context 'wallets'
   include_context 'payins'

data/spec/{lib/mangopay → mangopay}/payin_card_web_spec.rb

@@ -1,56 +1,54 @@
-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
-      refund = MangoPay::PayIn.refund(payin['Id'], {AuthorId: payin['AuthorId']})
-      expect(refund['Id']).not_to be_nil
-      expect(refund['Type']).to eq('PAYOUT')
-      expect(refund['Nature']).to eq('REFUND')
-      expect(refund['InitialTransactionType']).to eq('PAYIN')
-      expect(refund['InitialTransactionId']).to eq(payin['Id'])
-      expect(refund['DebitedWalletId']).to eq(payin['CreditedWalletId'])
-      expect(refund['Status']).to eq('FAILED')
-      expect(refund['ResultCode']).to eq('001001')
-      expect(refund['ResultMessage']).to eq('Unsufficient wallet balance')
-    end
-  end
-
-end
+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
+      refund = MangoPay::PayIn.refund(payin['Id'], {AuthorId: payin['AuthorId']})
+      expect(refund['Id']).not_to be_nil
+      expect(refund['Type']).to eq('PAYOUT')
+      expect(refund['Nature']).to eq('REFUND')
+      expect(refund['InitialTransactionType']).to eq('PAYIN')
+      expect(refund['InitialTransactionId']).to eq(payin['Id'])
+      expect(refund['DebitedWalletId']).to eq(payin['CreditedWalletId'])
+      expect(refund['Status']).to eq('FAILED')
+      expect(refund['ResultCode']).to eq('001001')
+      expect(refund['ResultMessage']).to eq('Unsufficient wallet balance')
+    end
+  end
+
+end

data/spec/{lib/mangopay → mangopay}/payin_preauthorized_direct_spec.rb

@@ -1,5 +1,3 @@
-require_relative '../../spec_helper'
-
 describe MangoPay::PayIn::PreAuthorized::Direct, type: :feature do
   include_context 'wallets'
   include_context 'payins'

data/spec/{lib/mangopay → mangopay}/payout_bankwire_spec.rb

@@ -1,56 +1,54 @@
-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, check_status = true)
-    expect(payout['Type']).to eq('PAYOUT')
-    expect(payout['Nature']).to eq('REGULAR')
-    expect(payout['PaymentType']).to eq('BANK_WIRE')
-    expect(payout['ExecutionDate']).to be_nil
-
-    # linked to correct bank account
-    expect(payout['BankAccountId']).to eq(new_bank_account['Id'])
-
-    if (check_status)
-      # not SUCCEEDED yet: waiting for processing
-      expect(payout['Status']).to eq('CREATED')
-      expect(payout['ResultCode']).to be_nil
-      expect(payout['ResultMessage']).to be_nil
-    end
-  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
-      payout = create_new_payout_bankwire(payin)
-      check_type_and_status(payout, false)
-      expect(payout['Status']).to eq('FAILED')
-      expect(payout['ResultCode']).to eq('001001')
-      expect(payout['ResultMessage']).to eq('Unsufficient wallet balance')
-    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
+describe MangoPay::PayOut::BankWire, type: :feature do
+  include_context 'bank_accounts'
+  include_context 'payins'
+  include_context 'payouts'
+
+  def check_type_and_status(payout, check_status = true)
+    expect(payout['Type']).to eq('PAYOUT')
+    expect(payout['Nature']).to eq('REGULAR')
+    expect(payout['PaymentType']).to eq('BANK_WIRE')
+    expect(payout['ExecutionDate']).to be_nil
+
+    # linked to correct bank account
+    expect(payout['BankAccountId']).to eq(new_bank_account['Id'])
+
+    if (check_status)
+      # not SUCCEEDED yet: waiting for processing
+      expect(payout['Status']).to eq('CREATED')
+      expect(payout['ResultCode']).to be_nil
+      expect(payout['ResultMessage']).to be_nil
+    end
+  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
+      payout = create_new_payout_bankwire(payin)
+      check_type_and_status(payout, false)
+      expect(payout['Status']).to eq('FAILED')
+      expect(payout['ResultCode']).to eq('001001')
+      expect(payout['ResultMessage']).to eq('Unsufficient wallet balance')
+    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