mangopay4-ruby-sdk 3.44.0

data/spec/mangopay/mandate_spec.rb

@@ -0,0 +1,99 @@
+describe MangoPay::Mandate do
+  include_context 'mandates'
+
+  def check_status(mandate)
+    expect(mandate['Status']).to eq('CREATED')
+    expect(mandate['MandateType']).to eq('DIRECT_DEBIT')
+    expect(mandate['ExecutionType']).to eq('WEB')
+  end
+
+  describe 'CREATE' do
+    it 'creates a mandate' do
+      mandate = new_mandate
+      expect(mandate['Id']).to_not be_nil
+      check_status(mandate)
+    end
+  end
+
+  describe 'FETCH' do
+
+    it 'fetches a mandate' do
+      created = new_mandate
+      fetched = MangoPay::Mandate.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      expect(fetched['CreationDate']).to eq(created['CreationDate'])
+      expect(fetched['UserId']).to eq(created['UserId'])
+      expect(fetched['BankAccountId']).to eq(created['BankAccountId'])
+      check_status(created)
+      check_status(fetched)
+    end
+
+    it 'fetches (all) mandates' do
+      created1 = create_new_mandate()
+      created2 = create_new_mandate()
+      fetched = MangoPay::Mandate.fetch({'per_page' => 2, 'sort' => 'CreationDate:desc'})
+
+      expect(fetched).to be_kind_of(Array)
+      expect(fetched.count).to eq 2 # exactly 2 as pagiantion requested
+
+      # all 2 are at top as lastly created
+      # but may share the same CreationDate
+      # so the order between them is undetermined
+      expect(fetched.map {|m| m['Id']}).to include(created1['Id'], created2['Id'])
+    end
+
+  end
+
+  describe 'FETCH FOR USER AND BANK ACCOUNT' do
+
+    it 'fetches mandates for user' do
+      created1 = create_new_mandate()
+      created2 = create_new_mandate()
+      expect(created1['UserId']).to eq(created2['UserId']) # both for same user
+
+      user_id = created1['UserId']
+      fetched = MangoPay::Mandate.fetch_for_user(user_id, {'per_page' => 2, 'sort' => 'CreationDate:desc'})
+
+      expect(fetched).to be_kind_of(Array)
+      expect(fetched.count).to eq 2 # exactly 2 as pagiantion requested
+      expect(fetched.map {|m| m['Id']}).to include(created1['Id'], created2['Id'])
+      expect((fetched.map {|m| m['UserId']}).uniq).to eq([user_id])
+    end
+
+    it 'fetches mandates for user bank account' do
+      created1 = create_new_mandate()
+      created2 = create_new_mandate()
+      expect(created1['UserId']).to eq(created2['UserId']) # both for same user
+      expect(created1['BankAccountId']).to eq(created2['BankAccountId']) # both for same bank account
+
+      user_id = created1['UserId']
+      bank_acc_id = created1['BankAccountId']
+      fetched = MangoPay::Mandate.fetch_for_user_bank_account(user_id, bank_acc_id, {'per_page' => 2, 'sort' => 'CreationDate:desc'})
+
+      expect(fetched).to be_kind_of(Array)
+      expect(fetched.count).to eq 2 # exactly 2 as pagiantion requested
+      expect(fetched.map {|m| m['Id']}).to include(created1['Id'], created2['Id'])
+      expect((fetched.map {|m| m['UserId']}).uniq).to eq([user_id])
+    end
+
+  end
+
+  describe 'CANCEL' do
+    it 'cancels a mandate' do
+      created = new_mandate
+      expect { MangoPay::Mandate.cancel(created['Id']) }.to raise_error { |err|
+        expect(err).to be_a MangoPay::ResponseError
+        expect(err.code).to eq '400'
+        expect(err.type).to eq 'mandate_cannot_be_cancelled'
+      }
+    end
+  end
+
+  describe 'FETCH Transactions' do
+    it "fetches a mandate's transactions" do
+      mandate = new_mandate
+      transactions = MangoPay::Mandate.transactions(mandate['Id'])
+      expect(transactions).to be_an(Array)
+    end
+  end
+end

data/spec/mangopay/payin_applepay_direct_spec.rb

@@ -0,0 +1,21 @@
+describe MangoPay::PayIn::ApplePay::Direct, 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('APPLEPAY')
+    expect(payin['ExecutionType']).to eq('DIRECT')
+    expect(payin['Status']).to eq('SUCCEEDED')
+  end
+
+  describe 'CREATE' do
+    it 'creates a applepay direct payin' do
+      pending("no cards to test for")
+      created = new_payin_applepay_direct
+      expect(created['Id']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+end
+

data/spec/mangopay/payin_bancontact_web_spec.rb

@@ -0,0 +1,30 @@
+describe MangoPay::PayIn::Bancontact::Web, type: :feature do
+  include_context 'wallets'
+  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('BCMC')
+    expect(payin['ExecutionType']).to eq('WEB')
+    expect(payin['Status']).to eq('CREATED')
+  end
+
+  describe 'CREATE' do
+    it 'creates a bancontact web payin' do
+      created = new_payin_bancontact_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_bancontact_web
+      fetched = MangoPay::PayIn.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
+    end
+  end
+end

data/spec/mangopay/payin_bankwire_direct_spec.rb

@@ -0,0 +1,74 @@
+describe MangoPay::PayIn::BankWire::Direct, type: :feature do
+  include_context 'wallets'
+  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('BANK_WIRE')
+    expect(payin['ExecutionType']).to eq('DIRECT')
+
+    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 bankwire direct payin' do
+      created = new_payin_bankwire_direct
+      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_bankwire_direct
+      fetched = MangoPay::PayIn.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      expect(fetched['CreationDate']).to eq(created['CreationDate'])
+      expect(fetched['DeclaredDebitedFunds']).to eq(created['DeclaredDebitedFunds'])
+      expect(fetched['CreditedWalletId']).to eq(created['CreditedWalletId'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
+    end
+  end
+
+###############################################
+# refund not implemented for this type of payin
+###############################################
+#  describe 'REFUND' do
+#    it 'refunds a payin' do
+#      payin = new_payin_bankwire_direct
+#      refund = MangoPay::PayIn.refund(payin['Id'], {AuthorId: payin['AuthorId']})
+#      expect(refund['Id']).not_to be_nil
+#      expect(refund['Status']).to eq('SUCCEEDED')
+#      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'])
+#    end
+#  end
+#
+###############################################
+# status is CREATED instead of SUCCEEDED
+# so no cash flow yet
+###############################################
+#  describe 'CASH FLOW' do
+#    it 'changes balances correctly' do
+#      wlt = new_wallet
+#      wallets_check_amounts(wlt, 0)
+#
+#      # payin: feed wlt1 with money
+#      payin = create_new_payin_bankwire_direct(wlt, 1000)
+#      wallets_reload_and_check_amounts(wlt, 1000)
+#
+#      # refund the payin
+#      refund = MangoPay::PayIn.refund(payin['Id'], {AuthorId: payin['AuthorId']})
+#      wallets_reload_and_check_amounts(wlt, 0)
+#    end
+#  end
+
+end

data/spec/mangopay/payin_bankwire_external_instruction_spec.rb

@@ -0,0 +1,104 @@
+describe MangoPay::PayIn::BankWire::ExternalInstruction, type: :feature do
+  include_context 'wallets'
+  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('BANK_WIRE')
+    expect(payin['ExecutionType']).to eq('EXTERNAL_INSTRUCTION')
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payin' do
+      backupConfig = MangoPay.configuration.clone
+      MangoPay.configure do |c|
+        c.preproduction = true
+        c.client_id = 'sdk-unit-tests'   
+        c.root_url = 'https://api.sandbox.mangopay.com'
+        c.client_apiKey = 'cqFfFrWfCcb7UadHNxx2C9Lo6Djw8ZduLi7J9USTmu8bhxxpju'
+        c.http_timeout = 10000
+      end
+
+      id = "payin_m_01JK6199ED4VGBP98ABRJVDS9D"
+      payIn = MangoPay::PayIn.fetch(id)
+      expect(payIn['Id']).to eq(id)
+      check_type_and_status(payIn)
+      MangoPay.configuration = backupConfig
+    end
+
+    it 'fetches a bankwire external instruction with iban' do
+      backupConfig = MangoPay.configuration.clone
+      MangoPay.configure do |c|
+        c.preproduction = true
+        c.client_id = 'sdk-unit-tests'
+        c.root_url = 'https://api.sandbox.mangopay.com'
+        c.client_apiKey = 'cqFfFrWfCcb7UadHNxx2C9Lo6Djw8ZduLi7J9USTmu8bhxxpju'
+        c.http_timeout = 10000
+      end
+
+      payInId = "payin_m_01JK6199ED4VGBP98ABRJVDS9D"
+      payIn = MangoPay::PayIn.fetch(payInId)
+      expect(payIn).to_not be(nil)
+      expect(payIn['Id']).to eq(payInId)
+      check_type_and_status(payIn)
+      MangoPay.configuration = backupConfig
+    end
+
+    it 'fetches a bankwire external instruction with account number' do
+      backupConfig = MangoPay.configuration.clone
+      MangoPay.configure do |c|
+        c.preproduction = true
+        c.client_id = 'sdk-unit-tests'
+        c.root_url = 'https://api.sandbox.mangopay.com'
+        c.client_apiKey = 'cqFfFrWfCcb7UadHNxx2C9Lo6Djw8ZduLi7J9USTmu8bhxxpju'
+        c.http_timeout = 10000
+      end
+
+      payInId = "payin_m_01JK6199ED4VGBP98ABRJVDS9D"
+      payIn = MangoPay::PayIn.fetch(payInId)
+      expect(payIn).to_not be(nil)
+      expect(payIn['Id']).to eq(payInId)
+      check_type_and_status(payIn)
+      MangoPay.configuration = backupConfig
+    end
+  end
+
+###############################################
+# refund not implemented for this type of payin
+###############################################
+#  describe 'REFUND' do
+#    it 'refunds a payin' do
+#      payin = new_payin_bankwire_direct
+#      refund = MangoPay::PayIn.refund(payin['Id'], {AuthorId: payin['AuthorId']})
+#      expect(refund['Id']).not_to be_nil
+#      expect(refund['Status']).to eq('SUCCEEDED')
+#      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'])
+#    end
+#  end
+#
+###############################################
+# status is CREATED instead of SUCCEEDED
+# so no cash flow yet
+###############################################
+#  describe 'CASH FLOW' do
+#    it 'changes balances correctly' do
+#      wlt = new_wallet
+#      wallets_check_amounts(wlt, 0)
+#
+#      # payin: feed wlt1 with money
+#      payin = create_new_payin_bankwire_direct(wlt, 1000)
+#      wallets_reload_and_check_amounts(wlt, 1000)
+#
+#      # refund the payin
+#      refund = MangoPay::PayIn.refund(payin['Id'], {AuthorId: payin['AuthorId']})
+#      wallets_reload_and_check_amounts(wlt, 0)
+#    end
+#  end
+
+end

data/spec/mangopay/payin_bizum_web_spec.rb

@@ -0,0 +1,54 @@
+describe MangoPay::PayIn::Bizum::Web, type: :feature do
+  include_context 'wallets'
+  include_context 'payins'
+
+  def check_type_and_status(payin)
+    expect(payin['Type']).to eq('PAYIN')
+    expect(payin['PaymentType']).to eq('BIZUM')
+    expect(payin['ExecutionType']).to eq('WEB')
+    expect(payin['Status']).to eq('CREATED')
+  end
+
+  describe 'CREATE' do
+    it 'creates a bizum web payin with phone' do
+      created = new_payin_bizum_web_with_phone
+      expect(created['Id']).not_to be_nil
+      expect(created['Phone']).not_to be_nil
+      expect(created['ReturnURL']).to be_nil
+      check_type_and_status(created)
+    end
+
+    it 'creates a bizum web payin with return url' do
+      created = new_payin_bizum_web_with_return_url
+      expect(created['Id']).not_to be_nil
+      expect(created['Phone']).to be_nil
+      expect(created['ReturnURL']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a bizum payin with phone' do
+      created = new_payin_bizum_web_with_phone
+      fetched = MangoPay::PayIn.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      expect(fetched['Phone']).not_to be_nil
+      expect(fetched['Phone']).to eq(created['Phone'])
+      expect(fetched['ReturnURL']).to be_nil
+      expect(fetched['ReturnURL']).to eq(created['ReturnURL'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
+    end
+
+    it 'fetches a bizum payin with return url' do
+      created = new_payin_bizum_web_with_return_url
+      fetched = MangoPay::PayIn.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      expect(fetched['ReturnURL']).not_to be_nil
+      expect(fetched['Phone']).to be_nil
+      expect(fetched['ReturnURL']).to eq(created['ReturnURL'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
+    end
+  end
+end

data/spec/mangopay/payin_blik_web_spec.rb

@@ -0,0 +1,41 @@
+describe MangoPay::PayIn::Blik::Web, type: :feature do
+  include_context 'wallets'
+  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('BLIK')
+    expect(payin['ExecutionType']).to eq('WEB')
+    expect(payin['Status']).to eq('CREATED')
+  end
+
+  describe 'CREATE' do
+    it 'creates a blik web payin' do
+      created = new_payin_blik_web
+      expect(created['Id']).not_to be_nil
+      expect(created['ReturnURL']).not_to be_nil
+      check_type_and_status(created)
+    end
+
+    it 'creates a blik web payin with code' do
+      created = new_payin_blik_web_with_code
+      expect(created['Id']).not_to be_nil
+      expect(created['Code']).not_to be_nil
+      expect(created['IpAddress']).not_to be_nil
+      expect(created['BrowserInfo']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payin' do
+      created = new_payin_blik_web
+      fetched = MangoPay::PayIn.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
+    end
+  end
+
+end

data/spec/mangopay/payin_card_direct_spec.rb

@@ -0,0 +1,69 @@
+describe MangoPay::PayIn::Card::Direct, type: :feature do
+  include_context 'wallets'
+  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('DIRECT')
+
+    # SUCCEEDED
+    expect(payin['Status']).to eq('SUCCEEDED')
+    expect(payin['ResultCode']).to eq('000000')
+    expect(payin['ResultMessage']).to eq('Success')
+    expect(payin['ExecutionDate']).to be > 0
+  end
+
+  describe 'CREATE' do
+    it 'creates a card direct payin' do
+      created = new_payin_card_direct
+      expect(created['Id']).not_to be_nil
+      # expect(created['Requested3DSVersion']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payin' do
+      created = new_payin_card_direct
+      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_direct
+      refund = MangoPay::PayIn.refund(payin['Id'], {AuthorId: payin['AuthorId']})
+      expect(refund['Id']).not_to be_nil
+      expect(refund['Status']).to eq('SUCCEEDED')
+      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'])
+    end
+  end
+
+  describe 'CASH FLOW' do
+    it 'changes balances correctly' do
+      wlt = new_wallet
+      wallets_check_amounts(wlt, 0)
+
+      # payin: feed wlt1 with money
+      payin = create_new_payin_card_direct(wlt, 1000)
+      wallets_reload_and_check_amounts(wlt, 1000)
+
+      # refund the payin
+      refund = MangoPay::PayIn.refund(payin['Id'], {AuthorId: payin['AuthorId']})
+      wallets_reload_and_check_amounts(wlt, 0)
+    end
+  end
+
+end

data/spec/mangopay/payin_card_web_spec.rb

@@ -0,0 +1,64 @@
+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 'CREATE with PaylineV2' do
+    it 'creates a card web payin with payline v2' do
+      created = new_payin_card_web_payline
+      expect(created['Id']).not_to be_nil
+      # expect(created['RedirectURL']).to include('https://www.maysite.com/payline_template/')
+      check_type_and_status(created)
+    end
+  end
+
+  describe 'EXTENDED' do
+    context 'when resource not exists' do
+      it 'fetches extended information' do
+        expect { MangoPay::PayIn::Card::Web.extended(1000000) }.to \
+          raise_error(MangoPay::ResponseError)
+      end
+    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 'FETCH Refunds' do
+    it "fetches the pay-in's refunds" do
+      payin = new_payin_card_web
+      refunds = MangoPay::PayIn.refunds(payin['Id'])
+      expect(refunds).to be_an(Array)
+    end
+  end
+
+end

data/spec/mangopay/payin_directdebit_direct_spec.rb

@@ -0,0 +1,37 @@
+describe MangoPay::PayIn::DirectDebit::Direct, 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('DIRECT_DEBIT')
+    expect(payin['ExecutionType']).to eq('DIRECT')
+
+    # FAILED: the related Mandate is not confirmed yet
+    expect(payin['Status']).to eq('FAILED')
+    expect(payin['ResultMessage']).to eq('The Status of this Mandate does not allow for payments')
+    expect(payin['ExecutionDate']).to be_nil
+  end
+  
+  describe 'CREATE' do
+    it 'creates a directdebit direct payin' do
+      created = new_payin_directdebit_direct
+      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_directdebit_direct
+      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
+
+end

data/spec/mangopay/payin_directdebit_web_spec.rb

@@ -0,0 +1,38 @@
+describe MangoPay::PayIn::DirectDebit::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('DIRECT_DEBIT')
+    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 directdebit web payin' do
+      created = new_payin_directdebit_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_directdebit_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
+
+end

data/spec/mangopay/payin_giropay_web_spec.rb

@@ -0,0 +1,30 @@
+describe MangoPay::PayIn::Giropay::Web, type: :feature do
+  include_context 'wallets'
+  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('GIROPAY')
+    expect(payin['ExecutionType']).to eq('WEB')
+    expect(payin['Status']).to eq('CREATED')
+  end
+
+  describe 'CREATE' do
+    it 'creates a giropay web payin' do
+      created = new_payin_giropay_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_giropay_web
+      fetched = MangoPay::PayIn.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
+    end
+  end
+end