mangopay 3.25.1 → 3.32.0

data/spec/mangopay/payin_paybybank_web_spec.rb

@@ -0,0 +1,30 @@
+describe MangoPay::PayIn::PayByBank::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('PAY_BY_BANK')
+    expect(payin['ExecutionType']).to eq('WEB')
+    expect(payin['Status']).to eq('CREATED')
+  end
+
+  describe 'CREATE' do
+    it 'creates a paybybank web payin' do
+      created = new_payin_paybybank_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_paybybank_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_paypal_web_spec.rb

@@ -32,6 +32,7 @@ describe MangoPay::PayIn::PayPal::Web, type: :feature do
 
   describe "FETCH" do
     it 'FETCHES a payIn with PayPal account email' do
+      pending("Expired PayIn id")
       payin_id = "54088959"
       buyer_account_email = "paypal-buyer-user@mangopay.com"
       payin = MangoPay::PayIn.fetch(id = payin_id)

data/spec/mangopay/payin_preauthorized_direct_spec.rb

@@ -44,6 +44,7 @@ describe MangoPay::PayIn::PreAuthorized::Direct, type: :feature do
   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')

data/spec/mangopay/payin_swish_web_spec.rb

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,30 @@
+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/payout_bankwire_spec.rb

@@ -32,11 +32,13 @@ describe MangoPay::PayOut::BankWire, type: :feature do
 
     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')
+      payout = create_new_payout_bankwire(payin, 10000)
+      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('001001')
+      expect(fetched['ResultMessage']).to eq('Unsufficient wallet balance')
     end
   end
 

data/spec/mangopay/recipient_spec.rb

@@ -0,0 +1,113 @@
+describe MangoPay::Recipient do
+  include_context 'recipient'
+
+  describe 'CREATE' do
+    it 'creates a new recipient' do
+      recipient = new_recipient
+      assert_recipient(recipient)
+      expect(recipient['PendingUserAction']).not_to be_nil
+    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 a recipient' 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
+  end
+
+  describe 'GET Schema' do
+    it 'fetches schema for LocalBankTransfer, Individual' do
+      schema = MangoPay::Recipient.get_schema('LocalBankTransfer', 'Individual', 'GBP')
+      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
+    end
+
+    it 'fetches schema for InternationalBankTransfer, Business' do
+      schema = MangoPay::Recipient.get_schema('InternationalBankTransfer', 'Business', 'GBP')
+      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
+    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
+end

data/spec/mangopay/recurring_payin_spec.rb

@@ -78,5 +78,145 @@ describe MangoPay::PayIn::RecurringPayments, type: :feature do
 
       expect(update).not_to be_nil
     end
+
+    it 'creates a recurring paypal payment CIT' do
+      wallet = new_wallet
+      recurring = MangoPay::PayIn::RecurringPayments::Recurring.create(
+        AuthorId: new_natural_user['Id'],
+        CreditedUserId: wallet['Owners'][0],
+        CreditedWalletId: wallet['Id'],
+        FirstTransactionDebitedFunds: {Currency: 'EUR', Amount: 1000},
+        FirstTransactionFees: {Currency: 'EUR', Amount: 0},
+        Billing: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        Shipping: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        PaymentType: 'PAYPAL'
+      )
+      expect(recurring).not_to be_nil
+      expect(recurring['Status']).not_to be_nil
+      expect(recurring['Id']).not_to be_nil
+
+      cit = MangoPay::PayIn::RecurringPayments::PayPalCIT.create(
+        {
+          "ReturnURL": "http://example.com",
+          "CancelURL": "http://example.net",
+          "LineItems": [
+            {
+              "Name": "Running shoes",
+              "Quantity": 1,
+              "UnitAmount": 1000,
+              "TaxAmount": 0,
+              "Description": "ID of Seller 1",
+              "Category": "PHYSICAL_GOODS"
+            }
+          ],
+          "Tag": "Created using the Mangopay API Postman collection",
+          "RecurringPayinRegistrationId": recurring['Id'],
+          "ShippingPreference": "SET_PROVIDED_ADDRESS",
+          "Reference": "abcd-efgh-ijkl",
+          "StatementDescriptor": "Example123"
+        }
+      )
+
+      expect(cit).not_to be_nil
+      expect(cit['Status']).to eq('CREATED')
+      expect(cit['PaymentType']).to eq('PAYPAL')
+      expect(cit['ExecutionType']).to eq('WEB')
+    end
+
+    it 'creates a recurring paypal payment MIT' do
+      wallet = new_wallet
+      recurring = MangoPay::PayIn::RecurringPayments::Recurring.create(
+        AuthorId: new_natural_user['Id'],
+        CreditedUserId: wallet['Owners'][0],
+        CreditedWalletId: wallet['Id'],
+        FirstTransactionDebitedFunds: {Currency: 'EUR', Amount: 1000},
+        FirstTransactionFees: {Currency: 'EUR', Amount: 0},
+        Billing: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        Shipping: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        PaymentType: 'PAYPAL'
+      )
+      expect(recurring).not_to be_nil
+      expect(recurring['Status']).not_to be_nil
+      expect(recurring['Id']).not_to be_nil
+
+      cit = MangoPay::PayIn::RecurringPayments::PayPalMIT.create(
+        {
+          "ReturnURL": "http://example.com",
+          "CancelURL": "http://example.net",
+          "LineItems": [
+            {
+              "Name": "Running shoes",
+              "Quantity": 1,
+              "UnitAmount": 1000,
+              "TaxAmount": 0,
+              "Description": "ID of Seller 1",
+              "Category": "PHYSICAL_GOODS"
+            }
+          ],
+          "Tag": "Created using the Mangopay API Postman collection",
+          "RecurringPayinRegistrationId": recurring['Id'],
+          "ShippingPreference": "SET_PROVIDED_ADDRESS",
+          "Reference": "abcd-efgh-ijkl",
+          "StatementDescriptor": "Example123",
+          "DebitedFunds": {
+            "Currency": "EUR",
+            "Amount": 1000
+          },
+          "Fees": {
+            "Currency": "EUR",
+            "Amount": 0
+          }
+        }
+      )
+
+      expect(cit).not_to be_nil
+      expect(cit['Status']).to eq('CREATED')
+      expect(cit['PaymentType']).to eq('PAYPAL')
+      expect(cit['ExecutionType']).to eq('WEB')
+    end
   end
 end