mangopay4-ruby-sdk 3.52.0 → 4.0.0

data/spec/mangopay/payin_giropay_web_spec.rb

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

data/spec/mangopay/payin_googlepay_direct_spec.rb

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

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

@@ -1,302 +0,0 @@
-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
-      created = create_new_intent_full_capture
-      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
-
-    it 'fetches the external providers list' do
-      response = MangoPay::PayIn::PayInIntent::Intent.get_external_providers_list
-      expect(response).not_to be_nil
-      expect(response).not_to be_empty
-      expect(response).to include('Mangopay')
-    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]
-      reversed = MangoPay::PayIn::PayInIntent::Split.reverse(intent['Id'], split['Id'])
-      expect(reversed['Status']).to eq('REVERSED')
-    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
-
-  describe 'Intent Refund' do
-    it 'creates a full refund' do
-      created_refund = create_new_intent_full_refund
-      expect(created_refund['Id']).not_to be_nil
-      expect(created_refund['Status']).to eq('REFUNDED')
-    end
-
-    it 'creates a partial refund' do
-      full_capture = create_new_intent_full_capture
-      to_create = {
-        "Amount": 1000,
-        "LineItems": [
-          {
-            "Id": full_capture['LineItems'][0]['Id'],
-            "Amount": 1000
-          }
-        ],
-        "ExternalData": {
-          "ExternalProcessingDate": 1727913600,
-          "ExternalProviderReference": SecureRandom.uuid,
-          "ExternalMerchantReference": SecureRandom.uuid,
-          "ExternalProviderName": "Stripe",
-          "ExternalProviderPaymentMethod": "PAYPAL"
-        }
-      }
-      created_refund = MangoPay::PayIn::PayInIntent::Refund.create(full_capture['Id'], to_create)
-      expect(created_refund['Id']).not_to be_nil
-      expect(created_refund['Status']).to eq('REFUNDED')
-    end
-
-    it 'fully reverses a refund' do
-      created_refund = create_new_intent_full_refund
-      to_create = {
-        "ExternalData": {
-          "ExternalProcessingDate": 1727913600,
-          "ExternalProviderReference": SecureRandom.uuid,
-          "ExternalMerchantReference": SecureRandom.uuid,
-          "ExternalProviderName": "Stripe",
-          "ExternalProviderPaymentMethod": "PAYPAL"
-        }
-      }
-      reversed_refund = MangoPay::PayIn::PayInIntent::Refund.reverse(created_refund['Id'], created_refund['Refund']['Id'], to_create)
-      expect(reversed_refund['Id']).not_to be_nil
-      expect(reversed_refund['Status']).to eq('REFUND_REVERSED')
-    end
-
-    it 'partially reverses a refund' do
-      created_refund = create_new_intent_full_refund
-      to_create = {
-        "Amount": 1000,
-        "LineItems": [
-          {
-            "Id": created_refund['LineItems'][0]['Id'],
-            "Amount": 1000
-          }
-        ],
-        "ExternalData": {
-          "ExternalProcessingDate": 1727913600,
-          "ExternalProviderReference": SecureRandom.uuid,
-          "ExternalMerchantReference": SecureRandom.uuid,
-          "ExternalProviderName": "Stripe",
-          "ExternalProviderPaymentMethod": "PAYPAL"
-        }
-      }
-      reversed_refund = MangoPay::PayIn::PayInIntent::Refund.reverse(created_refund['Id'], created_refund['Refund']['Id'], to_create)
-      expect(reversed_refund['Id']).not_to be_nil
-      expect(reversed_refund['Status']).to eq('REFUND_REVERSED')
-    end
-
-    it 'creates a full dispute' do
-      capture = create_new_intent_full_capture
-      to_create = {
-        "ExternalData": {
-          "ExternalProcessingDate": 1727913600,
-          "ExternalProviderReference": SecureRandom.uuid,
-          "ExternalMerchantReference": SecureRandom.uuid,
-          "ExternalProviderName": "Stripe",
-          "ExternalProviderPaymentMethod": "PAYPAL"
-        }
-      }
-      created_dispute = MangoPay::PayIn::PayInIntent::Dispute.create(capture['Id'], capture['Capture']['Id'], to_create)
-      expect(created_dispute['Id']).not_to be_nil
-      expect(created_dispute['Status']).to eq('DISPUTED')
-    end
-
-    it 'creates a partial dispute' do
-      capture = create_new_intent_full_capture
-      to_create = {
-        "Amount": 1000,
-        "LineItems": [
-          {
-            "Id": capture['LineItems'][0]['Id'],
-            "Amount": 1000
-          }
-        ],
-        "ExternalData": {
-          "ExternalProcessingDate": 1727913600,
-          "ExternalProviderReference": SecureRandom.uuid,
-          "ExternalMerchantReference": SecureRandom.uuid,
-          "ExternalProviderName": "Stripe",
-          "ExternalProviderPaymentMethod": "PAYPAL"
-        }
-      }
-      created_dispute = MangoPay::PayIn::PayInIntent::Dispute.create(capture['Id'], capture['Capture']['Id'], to_create)
-      expect(created_dispute['Id']).not_to be_nil
-      expect(created_dispute['Status']).to eq('DISPUTED')
-    end
-
-    it 'updates dispute outcome' do
-      capture = create_new_intent_full_capture
-      to_create = {
-        "ExternalData": {
-          "ExternalProcessingDate": 1727913600,
-          "ExternalProviderReference": SecureRandom.uuid,
-          "ExternalMerchantReference": SecureRandom.uuid,
-          "ExternalProviderName": "Stripe",
-          "ExternalProviderPaymentMethod": "PAYPAL"
-        }
-      }
-      created_dispute = MangoPay::PayIn::PayInIntent::Dispute.create(capture['Id'], capture['Capture']['Id'], to_create)
-
-      dto = {
-        "Decision": "DEFENDED"
-      }
-      updated = MangoPay::PayIn::PayInIntent::Dispute.update_outcome(capture['Id'], capture['Capture']['Id'], created_dispute['Dispute']['Id'], dto)
-
-      expect(updated['Id']).not_to be_nil
-      expect(updated['Decision']).to eq('DEFENDED')
-    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
-
-  def create_new_intent_full_capture
-    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"
-      }
-    }
-
-    return MangoPay::PayIn::PayInIntent::Capture.create(intent['Id'], to_create)
-  end
-
-  def create_new_intent_full_refund
-    full_capture = create_new_intent_full_capture
-    to_create = {
-      "ExternalData": {
-        "ExternalProcessingDate": 1727913600,
-        "ExternalProviderReference": SecureRandom.uuid,
-        "ExternalMerchantReference": SecureRandom.uuid,
-        "ExternalProviderName": "Stripe",
-        "ExternalProviderPaymentMethod": "PAYPAL"
-      }
-    }
-    return MangoPay::PayIn::PayInIntent::Refund.create(full_capture['Id'], to_create)
-  end
-end

data/spec/mangopay/payin_klarna_web_spec.rb

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

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

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

@@ -1,56 +0,0 @@
-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_paypal_web_spec.rb

@@ -1,114 +0,0 @@
-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
-
-    xit 'fetches data collection' do
-      # skipped because API 500 error
-      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