mangopay4-ruby-sdk 3.47.0 → 4.1.0

data/spec/mangopay/payin_preauthorized_direct_spec.rb

@@ -1,118 +0,0 @@
-describe MangoPay::PayIn::PreAuthorized::Direct, type: :feature do
-  include_context 'wallets'
-  include_context 'payins'
-  include_context 'users'
-
-  def check_type_and_status(payin)
-    expect(payin['Type']).to eq('PAYIN')
-    expect(payin['Nature']).to eq('REGULAR')
-    expect(payin['PaymentType']).to eq('PREAUTHORIZED')
-    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 preauthorized direct payin' do
-      created = new_payin_preauthorized_direct
-      # wait for the transactions to be created
-      sleep(2)
-      transactions = MangoPay::PreAuthorization.transactions(created['PreauthorizationId'])
-      expect(created['Id']).not_to be_nil
-      expect(transactions[0]['Status']).to eq('SUCCEEDED')
-      check_type_and_status(created)
-    end
-  end
-
-  describe 'FETCH' do
-    it 'fetches a payin' do
-      created = new_payin_preauthorized_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_preauthorized_direct
-      sleep(2)
-      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_preauthorized_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
-
-  begin
-    describe 'CREATE AND VIEW PRE AUTHORIZED DEPOSIT' do
-      it 'creates a card direct pre authorized deposit payin' do
-        wallet = new_wallet
-        author = new_natural_user
-        card_registration = new_card_registration_completed
-        deposit = create_new_deposit(card_registration['CardId'], author['Id'])
-
-        created = create_new_payin_pre_authorized_deposit_direct(deposit['Id'], author['Id'], wallet['Id'])
-
-        expect(created['Id']).not_to be_nil
-        check_type_and_status(created)
-        expect(created['DepositId']).to eq(deposit['Id'])
-      end
-
-      it 'creates a card direct pre authorized deposit payin prior to complement' do
-        wallet = new_wallet
-        author = new_natural_user
-        card_registration = new_card_registration_completed
-        deposit = create_new_deposit(card_registration['CardId'], author['Id'])
-
-        created = create_new_deposit_pre_authorized_pay_in_prior_to_complement(deposit['Id'], author['Id'], wallet['Id'])
-
-        expect(created['Id']).not_to be_nil
-        check_type_and_status(created)
-        expect(created['DepositId']).to eq(deposit['Id'])
-      end
-
-      # skip because of PSP error
-      xit 'creates a card direct pre authorized deposit payin complement' do
-        wallet = new_wallet
-        author = new_natural_user
-        card_registration = new_card_registration_completed
-        deposit = create_new_deposit(card_registration['CardId'], author['Id'])
-        MangoPay::Deposit.update(deposit['Id'], {PaymentStatus: 'NO_SHOW_REQUESTED'})
-
-        created = create_new_deposit_pre_authorized_pay_in_complement(deposit['Id'], author['Id'], wallet['Id'])
-
-        expect(created['Id']).not_to be_nil
-        check_type_and_status(created)
-        expect(created['DepositId']).to eq(deposit['Id'])
-      end
-    end
-  end
-end

data/spec/mangopay/payin_satispay_web_spec.rb

@@ -1,32 +0,0 @@
-describe MangoPay::PayIn::Satispay::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('SATISPAY')
-    expect(payin['ExecutionType']).to eq('WEB')
-    expect(payin['Status']).to eq('CREATED')
-  end
-
-  describe 'CREATE' do
-    it 'creates a satispay web payin' do
-      created = new_payin_satispay_web
-      expect(created['Id']).not_to be_nil
-      expect(created['Country']).not_to be_nil
-      check_type_and_status(created)
-    end
-  end
-
-  describe 'FETCH' do
-    it 'fetches a payin' do
-      created = new_payin_satispay_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_swish_web_spec.rb

@@ -1,30 +0,0 @@
-describe MangoPay::PayIn::Swish::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('SWISH')
-    expect(payin['ExecutionType']).to eq('WEB')
-    expect(payin['Status']).to eq('CREATED')
-  end
-
-  describe 'CREATE' do
-    it 'creates a swish web payin' do
-      created = new_payin_swish_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_swish_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_twint_web_spec.rb

@@ -1,30 +0,0 @@
-describe MangoPay::PayIn::Twint::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('TWINT')
-    expect(payin['ExecutionType']).to eq('WEB')
-    expect(payin['Status']).to eq('CREATED')
-  end
-
-  describe 'CREATE' do
-    it 'creates a twint web payin' do
-      created = new_payin_twint_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_twint_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/payment_method_metadata_spec.rb

@@ -1,15 +0,0 @@
-describe MangoPay::PaymentMethodMetadata, type: :feature do
-  include_context 'payment_method_metadata'
-
-  describe 'GET PAYMENT METHOD METADATA' do
-    it 'gets a new payment method metadata' do
-      metadata = get_payment_method_metadata
-
-      expect(metadata).not_to be_nil
-      expect(metadata['IssuerCountryCode']).not_to be_nil
-      expect(metadata['IssuingBank']).not_to be_nil
-      expect(metadata['BinData']).not_to be_nil
-      expect(metadata['BinData'][0]['CardType']).not_to be_nil
-    end
-  end
-end

data/spec/mangopay/payout_bankwire_spec.rb

@@ -1,93 +0,0 @@
-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')
-
-    # 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['ExecutionDate']).to be_nil
-      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, 100)
-      sleep(2)
-      fetched = MangoPay::PayOut::BankWire.get_bankwire(payout['Id'])
-      check_type_and_status(payout, true)
-      expect(fetched['Status']).to eq('FAILED')
-      expect(fetched['ResultCode']).to eq('002998')
-      # expect(fetched['ResultMessage']).to eq('Unsufficient wallet balance')
-    end
-  end
-
-  describe 'Get Bankwire' do
-    it 'gets a bankwire' do
-      created = new_payout_bankwire
-      fetched = MangoPay::PayOut::BankWire.get_bankwire(created['Id'])
-      expect(fetched['Id']).to eq(created['Id'])
-      expect(fetched['CreationDate']).to eq(created['CreationDate'])
-    end
-  end
-
-  describe 'Check Eligibility' do
-    it 'checks the eligibility of a payout' do
-      created = new_payout_bankwire
-
-      eligibility = MangoPay::PayOut::InstantPayoutEligibility::Reachability.create(
-        AuthorId: created['AuthorId'],
-        DebitedFunds: {
-          Amount: 10,
-          Currency: 'EUR'
-        },
-        PayoutModeRequested: 'INSTANT_PAYMENT',
-        BankAccountId: created['BankAccountId'],
-        DebitedWalletId: created['DebitedWalletId']
-      )
-
-      expect(created).not_to be_nil
-      expect(eligibility).not_to be_nil
-    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
-
-  describe 'GET Refunds' do
-    it "fetches the pay-out's refunds" do
-      payout = new_payout_bankwire
-      refunds = MangoPay::PayOut.refunds(payout['Id'])
-      expect(refunds).to be_an(Array)
-    end
-  end
-
-end

data/spec/mangopay/preauthorization_spec.rb

@@ -1,51 +0,0 @@
-describe MangoPay::PreAuthorization do
-  include_context 'users'
-  include_context 'payins'
-
-  describe 'CREATE' do
-    it 'creates a new card pre-authorization' do
-      cardreg = new_card_registration_completed
-      created = new_card_preauthorization
-      expect(created['Id']).not_to be_nil
-      expect(created['CardId']).to eq(cardreg['CardId'])
-      expect(created['AuthorId']).to eq(new_natural_user["Id"])
-      expect(created['PayInId']).to be_nil
-      expect(created['Status']).to eq('SUCCEEDED')
-      expect(created['PaymentStatus']).to eq('WAITING')
-      expect(created['PaymentType']).to eq('CARD')
-      expect(created['ExecutionType']).to eq('DIRECT')
-      # expect(created['Requested3DSVersion']).to eq('V2_1')
-    end
-  end
-
-  describe 'UPDATE' do
-    it 'updates a card pre-authorization' do
-      created = new_card_preauthorization
-      updated = MangoPay::PreAuthorization.update(created['Id'] ,{
-        PaymentStatus: 'CANCELED'
-      })
-      expect(updated['PaymentStatus']).to eq('CANCELED')
-    end
-  end
-
-  describe 'FETCH' do
-    it 'fetches a card pre-authorization' do
-      created = new_card_preauthorization
-      fetched = MangoPay::PreAuthorization.fetch(created['Id'])
-      expect(fetched['Id']).to eq(created['Id'])
-      expect(fetched['CardId']).to eq(created['CardId'])
-      expect(fetched['AuthorId']).to eq(created['AuthorId'])
-      expect(fetched['Tag']).to eq(created['Tag'])
-    end
-  end
-
-  describe 'FETCH FOR CARD' do
-    it "fetches a card's pre-authorizations" do
-      created = new_card_preauthorization
-      fetched = MangoPay::Card.get_pre_authorizations(created['CardId'])
-
-      expect(fetched).to be_an(Array)
-    end
-  end
-
-end

data/spec/mangopay/recipient_spec.rb

@@ -1,134 +0,0 @@
-describe MangoPay::Recipient do
-  include_context 'recipient'
-
-  describe 'CREATE' do
-    it 'creates a new recipient' do
-      recipient = new_recipient
-      assert_recipient(recipient)
-      expect(recipient['Status']).to eq('PENDING')
-    end
-  end
-
-  describe 'GET' do
-    it 'fetches a recipient' do
-      recipient = new_recipient
-      fetched = MangoPay::Recipient.get(recipient['Id'])
-      assert_recipient(fetched)
-    end
-  end
-
-  describe 'GET User Recipients' do
-    it 'fetches recipients without query param' do
-      john = create_new_natural_user_sca_owner
-      create_new_recipient(john['Id'])
-      fetched = MangoPay::Recipient.get_user_recipients(john['Id'])
-      expect(fetched).not_to be_nil
-      expect(fetched).to be_kind_of(Array)
-      expect(fetched).not_to be_empty
-    end
-
-    it 'fetches recipients with scope PAYOUT' do
-      john = create_new_natural_user_sca_owner
-      create_new_recipient(john['Id'])
-      fetched = MangoPay::Recipient.get_user_recipients(john['Id'], {RecipientScope: "PAYOUT"})
-      expect(fetched).not_to be_nil
-      expect(fetched).to be_kind_of(Array)
-      expect(fetched).not_to be_empty
-    end
-
-    it 'fetches recipients with scope PAYIN' do
-      john = create_new_natural_user_sca_owner
-      create_new_recipient(john['Id'])
-      fetched = MangoPay::Recipient.get_user_recipients(john['Id'], {RecipientScope: "PAYIN"})
-      expect(fetched).not_to be_nil
-      expect(fetched).to be_kind_of(Array)
-      expect(fetched).to be_empty
-    end
-  end
-
-  describe 'GET Schema' do
-    it 'fetches schema for LocalBankTransfer, Individual' do
-      schema = MangoPay::Recipient.get_schema('LocalBankTransfer', 'Individual', 'GBP', 'GB')
-      expect(schema).not_to be_nil
-      expect(schema['DisplayName']).not_to be_nil
-      expect(schema['Currency']).not_to be_nil
-      expect(schema['RecipientType']).not_to be_nil
-      expect(schema['PayoutMethodType']).not_to be_nil
-      expect(schema['RecipientScope']).not_to be_nil
-      expect(schema['Tag']).not_to be_nil
-      expect(schema['IndividualRecipient']).not_to be_nil
-      expect(schema['LocalBankTransfer']).not_to be_nil
-      expect(schema['BusinessRecipient']).to be_nil
-      expect(schema['InternationalBankTransfer']).to be_nil
-      expect(schema['Country']).not_to be_nil
-    end
-
-    it 'fetches schema for InternationalBankTransfer, Business' do
-      schema = MangoPay::Recipient.get_schema('InternationalBankTransfer', 'Business', 'GBP', 'GB')
-      expect(schema).not_to be_nil
-      expect(schema['DisplayName']).not_to be_nil
-      expect(schema['Currency']).not_to be_nil
-      expect(schema['RecipientType']).not_to be_nil
-      expect(schema['PayoutMethodType']).not_to be_nil
-      expect(schema['RecipientScope']).not_to be_nil
-      expect(schema['Tag']).not_to be_nil
-      expect(schema['BusinessRecipient']).not_to be_nil
-      expect(schema['InternationalBankTransfer']).not_to be_nil
-      expect(schema['IndividualRecipient']).to be_nil
-      expect(schema['LocalBankTransfer']).to be_nil
-      expect(schema['Country']).not_to be_nil
-    end
-  end
-
-  describe 'GET Payout Methods' do
-    it 'fetches payout methods' do
-      payout_methods = MangoPay::Recipient.get_payout_methods('DE', 'EUR')
-      expect(payout_methods).not_to be_nil
-      expect(payout_methods['AvailablePayoutMethods']).to be_kind_of(Array)
-      expect(payout_methods['AvailablePayoutMethods']).not_to be_empty
-    end
-  end
-
-  describe 'VALIDATE' do
-    it 'validates a recipient' do
-      recipient = define_new_recipient
-      john = create_new_natural_user_sca_owner
-      # it should pass
-      MangoPay::Recipient.validate(recipient, john['Id'])
-
-      # it should throw error
-      recipient['Currency'] = nil
-      expect { MangoPay::Recipient.validate(recipient, john['Id']) }.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
-
-  describe 'DEACTIVATE' do
-    it 'deactivates a recipient' do
-      pending("a recipient needs to be manually activated before running the test")
-      john = create_new_natural_user_sca_owner
-      recipient = create_new_recipient(john['Id'])
-      deactivated = MangoPay::Recipient.deactivate(recipient['Id'])
-      fetched = MangoPay::Recipient.get(recipient['Id'])
-      expect(deactivated['Status']).to eq('DEACTIVATED')
-      expect(fetched['Status']).to eq('DEACTIVATED')
-    end
-  end
-end
-
-
-def assert_recipient(recipient)
-  expect(recipient).not_to be_nil
-  expect(recipient['Status']).not_to be_nil
-  expect(recipient['DisplayName']).not_to be_nil
-  expect(recipient['PayoutMethodType']).not_to be_nil
-  expect(recipient['RecipientType']).not_to be_nil
-  expect(recipient['IndividualRecipient']).not_to be_nil
-  expect(recipient['LocalBankTransfer']).not_to be_nil
-  expect(recipient['RecipientScope']).not_to be_nil
-  expect(recipient['UserId']).not_to be_nil
-  expect(recipient['Country']).not_to be_nil
-end