mangopay4-ruby-sdk 3.44.0

data/spec/mangopay/payin_googlepay_direct_spec.rb

@@ -0,0 +1,21 @@
+describe MangoPay::PayIn::GooglePay::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('GOOGLE_PAY')
+    expect(payin['ExecutionType']).to eq('DIRECT')
+    expect(payin['Status']).to eq('CREATED')
+  end
+
+  describe 'CREATE' do
+    it 'creates a googlepay direct payin' do
+      pending("Cannot be tested due to impossibility to generate payment_data in test")
+      created = new_payin_googlepay_direct
+      expect(created['Id']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+end
+

data/spec/mangopay/payin_ideal_web_spec.rb

@@ -0,0 +1,30 @@
+describe MangoPay::PayIn::Ideal::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('IDEAL')
+    expect(payin['ExecutionType']).to eq('WEB')
+    expect(payin['Status']).to eq('CREATED')
+  end
+
+  describe 'CREATE' do
+    it 'creates a ideal web payin' do
+      created = new_payin_ideal_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_ideal_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_intent_spec.rb

@@ -0,0 +1,151 @@
+describe MangoPay::PayIn::PayInIntent, type: :feature do
+  include_context 'wallets'
+  include_context 'intents'
+
+  describe 'CREATE' do
+    it 'creates a payin intent authorization' do
+      created = new_payin_intent_authorization
+      expect(created['Id']).not_to be_nil
+      expect(created['Status']).to eq('AUTHORIZED')
+    end
+
+    it 'creates a payin intent full capture' do
+      intent = new_payin_intent_authorization
+      to_create = {
+        "ExternalData": {
+          "ExternalProcessingDate": "01-10-2029",
+          "ExternalProviderReference": SecureRandom.uuid,
+          "ExternalMerchantReference": "Order-xyz-35e8490e-2ec9-4c82-978e-c712a3f5ba16",
+          "ExternalProviderName": "Stripe",
+          "ExternalProviderPaymentMethod": "PAYPAL"
+        }
+      }
+
+      created = MangoPay::PayIn::PayInIntent::Capture.create(intent['Id'], to_create)
+      expect(created['Id']).not_to be_nil
+      expect(created['Status']).to eq('CAPTURED')
+    end
+
+    it 'creates a payin intent partial capture' do
+      intent = new_payin_intent_authorization
+      to_create = {
+        "Amount": 1000,
+        "Currency": "EUR",
+        "PlatformFeesAmount": 0,
+        "ExternalData": {
+          "ExternalProcessingDate": "01-10-2024",
+          "ExternalProviderReference": SecureRandom.uuid,
+          "ExternalMerchantReference": "Order-xyz-35e8490e-2ec9-4c82-978e-c712a3f5ba16",
+          "ExternalProviderName": "Stripe",
+          "ExternalProviderPaymentMethod": "PAYPAL"
+        },
+        "LineItems": [
+          {
+            "Amount": 1000,
+            "Id": intent['LineItems'][0]['Id']
+          }
+        ]
+      }
+
+      created = MangoPay::PayIn::PayInIntent::Capture.create(intent['Id'], to_create)
+      expect(created['Id']).not_to be_nil
+      expect(created['Status']).to eq('CAPTURED')
+    end
+  end
+
+  describe 'GET' do
+    it 'fetches an intent' do
+      intent = new_payin_intent_authorization
+      fetched =  MangoPay::PayIn::PayInIntent::Intent.get(intent['Id'])
+      expect(intent['Id']).to eq(fetched['Id'])
+      expect(intent['Status']).to eq(fetched['Status'])
+    end
+  end
+
+  describe 'CANCEL' do
+    it 'cancels an intent' do
+      intent = new_payin_intent_authorization
+      canceled =  MangoPay::PayIn::PayInIntent::Intent.cancel(intent['Id'], {
+        "ExternalData": {
+          "ExternalProcessingDate": 1728133765,
+          "ExternalProviderReference": SecureRandom.uuid,
+        }
+      })
+      expect(canceled['Status']).to eq('CANCELLED')
+    end
+  end
+
+  describe 'SPLITS' do
+    it 'creates a split' do
+      intent = new_payin_intent_authorization
+      created = create_new_splits(intent)
+      expect(created['Splits']).to be_kind_of(Array)
+      expect(created['Splits']).not_to be_empty
+      expect(created['Splits'][0]['Status']).to eq('CREATED')
+    end
+
+    it 'executes split' do
+      intent = new_payin_intent_authorization
+      split = create_new_splits(intent)['Splits'][0]
+      expect {
+        MangoPay::PayIn::PayInIntent::Split.execute(intent['Id'], split['Id'])
+      }.to raise_error { |err|
+        expect(err).to be_a MangoPay::ResponseError
+        expect(err.code).to eq '400'
+        expect(err.details['Type']).to eq 'param_error'
+      }
+    end
+
+    it 'reverses split' do
+      intent = new_payin_intent_authorization
+      split = create_new_splits(intent)['Splits'][0]
+      expect {
+        MangoPay::PayIn::PayInIntent::Split.reverse(intent['Id'], split['Id'])
+      }.to raise_error { |err|
+        expect(err).to be_a MangoPay::ResponseError
+        expect(err.code).to eq '400'
+        expect(err.details['Type']).to eq 'param_error'
+      }
+    end
+
+    it 'fetches split' do
+      intent = new_payin_intent_authorization
+      split = create_new_splits(intent)['Splits'][0]
+      fetched = MangoPay::PayIn::PayInIntent::Split.get(intent['Id'], split['Id'])
+      expect(fetched['Status']).to eq('CREATED')
+    end
+
+    it 'updates split' do
+      intent = new_payin_intent_authorization
+      split = create_new_splits(intent)['Splits'][0]
+      params = {
+        LineItemId: split['LineItemId'],
+        Description: 'updated split'
+      }
+      updated = MangoPay::PayIn::PayInIntent::Split.update(intent['Id'], split['Id'], params)
+      expect(updated['Description']).to eq('updated split')
+    end
+  end
+
+  def create_new_splits(intent)
+    full_capture = {
+      "ExternalData": {
+        "ExternalProcessingDate": "01-10-2029",
+        "ExternalProviderReference": SecureRandom.uuid,
+        "ExternalMerchantReference": "Order-xyz-35e8490e-2ec9-4c82-978e-c712a3f5ba16",
+        "ExternalProviderName": "Stripe",
+        "ExternalProviderPaymentMethod": "PAYPAL"
+      }
+    }
+    MangoPay::PayIn::PayInIntent::Capture.create(intent['Id'], full_capture)
+    split = {
+      "Splits": [
+        {
+          "LineItemId": intent['LineItems'][0]['Id'],
+          "SplitAmount": 10
+        }
+      ]
+    }
+    return  MangoPay::PayIn::PayInIntent::Split.create(intent['Id'], split)
+  end
+end

data/spec/mangopay/payin_klarna_web_spec.rb

@@ -0,0 +1,32 @@
+describe MangoPay::PayIn::Klarna::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('KLARNA')
+    expect(payin['ExecutionType']).to eq('WEB')
+    expect(payin['Status']).to eq('CREATED')
+  end
+
+  describe 'CREATE' do
+    it 'creates a klarna web payin' do
+      created = new_payin_klarna_web
+      expect(created['Id']).not_to be_nil
+      expect(created['ReturnURL']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payin' do
+      created = new_payin_klarna_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_mbway_web_spec.rb

@@ -0,0 +1,32 @@
+describe MangoPay::PayIn::Mbway::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('MBWAY')
+    expect(payin['ExecutionType']).to eq('WEB')
+    expect(payin['Status']).to eq('CREATED')
+  end
+
+  describe 'CREATE' do
+    it 'creates a mbway web payin' do
+      created = new_payin_mbway_web
+      expect(created['Id']).not_to be_nil
+      expect(created['Phone']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payin' do
+      created = new_payin_mbway_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_multibanco_web_spec.rb

@@ -0,0 +1,31 @@
+describe MangoPay::PayIn::Multibanco::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('MULTIBANCO')
+    expect(payin['ExecutionType']).to eq('WEB')
+    expect(payin['Status']).to eq('CREATED')
+  end
+
+  describe 'CREATE' do
+    it 'creates a multibanco web payin' do
+      created = new_payin_multibanco_web
+      expect(created['Id']).not_to be_nil
+      expect(created['ReturnURL']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payin' do
+      created = new_payin_multibanco_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_paybybank_web_spec.rb

@@ -0,0 +1,56 @@
+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
+
+  describe "FETCH SUPPORTED BANKS" do
+    it "fetches supported banks unfiltered" do
+      result = MangoPay::PayIn::PayByBank::Web.get_supported_banks
+      expect(result['SupportedBanks']['Countries']).to be_kind_of(Array)
+      expect(result['SupportedBanks']['Countries']).not_to be_empty
+    end
+
+    it "fetches supported banks filtered" do
+      result = MangoPay::PayIn::PayByBank::Web.get_supported_banks({CountryCodes: "DE"})
+      expect(result['SupportedBanks']['Countries']).to be_kind_of(Array)
+      expect(result['SupportedBanks']['Countries'][0]['Banks'].count).to be(5)
+    end
+
+    it "fetches supported banks paginated" do
+      result = MangoPay::PayIn::PayByBank::Web.get_supported_banks({per_page: 2, page: 1})
+      expect(result['SupportedBanks']['Countries']).to be_kind_of(Array)
+      expect(result['SupportedBanks']['Countries'][0]['Banks'].count).to be(2)
+    end
+
+    it "fetches supported banks paginated and filtered" do
+      result = MangoPay::PayIn::PayByBank::Web.get_supported_banks({per_page: 2, page: 1, CountryCodes: "DE"})
+      expect(result['SupportedBanks']['Countries']).to be_kind_of(Array)
+      expect(result['SupportedBanks']['Countries'][0]['Banks'].count).to be(2)
+    end
+  end
+end

data/spec/mangopay/payin_payconiq_web_spec.rb

@@ -0,0 +1,31 @@
+describe MangoPay::PayIn::Payconiq::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('PAYCONIQ')
+    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 payconiq web payin' do
+      created = new_payin_payconiq_web
+      expect(created['Id']).not_to be_nil
+      check_type_and_status(created)
+    end
+
+    it 'creates a payconiq web payin using the old endpoint' do
+      created = new_payin_payconiq_web_legacy
+      expect(created['Id']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+
+end

data/spec/mangopay/payin_paypal_web_spec.rb

@@ -0,0 +1,113 @@
+describe MangoPay::PayIn::PayPal::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('PAYPAL')
+    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 paypal web payin' do
+      created = new_payin_paypal_web
+      expect(created['Id']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+
+  describe 'CREATE V2' do
+    it 'creates a paypal web v2 payin' do
+      created = new_payin_paypal_web_v2
+      expect(created['Id']).not_to be_nil
+      # generic operation error
+      # check_type_and_status(created)
+    end
+  end
+
+  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)
+
+      expect(payin).not_to be_nil
+      expect(payin["PaypalBuyerAccountEmail"]).not_to be_nil
+      expect(payin["PaypalBuyerAccountEmail"]).to eq(buyer_account_email)
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payin' do
+      created = new_payin_paypal_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
+
+  # skip because of Generic Operation Error
+  describe 'FETCH V2' do
+    xit 'fetches a payin' do
+      created = new_payin_paypal_web_v2
+      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 'Data Collection' do
+    it 'creates data collection' do
+      created = MangoPay::PayIn::PayPal::Web.create_data_collection(get_data_collection_dto)
+      expect(created['dataCollectionId']).not_to be_nil
+    end
+
+    it 'fetches data collection' do
+      created = MangoPay::PayIn::PayPal::Web.create_data_collection(get_data_collection_dto)
+      fetched = MangoPay::PayIn::PayPal::Web.get_data_collection(created['dataCollectionId'])
+      expect(fetched['DataCollectionId']).to eq(created['dataCollectionId'])
+      expect(fetched['sender_first_name']).to eq('Jane')
+      expect(fetched['sender_last_name']).to eq('Doe')
+    end
+  end
+
+  def get_data_collection_dto
+    return {
+      "sender_account_id": "A12345N343",
+      "sender_first_name": "Jane",
+      "sender_last_name": "Doe",
+      "sender_email": "jane.doe@sample.com",
+      "sender_phone": "(042)11234567",
+      "sender_address_zip": "75009",
+      "sender_country_code": "FR",
+      "sender_create_date": "2012-12-09T19:14:55.277-0:00",
+      "sender_signup_ip": "10.220.90.20",
+      "sender_popularity_score": "high",
+      "receiver_account_id": "A12345N344",
+      "receiver_create_date": "2012-12-09T19:14:55.277-0:00",
+      "receiver_email": "jane@sample.com",
+      "receiver_address_country_code": "FR",
+      "business_name": "Jane Ltd",
+      "recipient_popularity_score": "high",
+      "first_interaction_date": "2012-12-09T19:14:55.277-0:00",
+      "txn_count_total": "34",
+      "vertical": "Household goods",
+      "transaction_is_tangible": "0"
+    }
+  end
+end

data/spec/mangopay/payin_preauthorized_direct_spec.rb

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

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