mangopay 3.33.0 → 3.42.0

data/spec/mangopay/payin_preauthorized_direct_spec.rb

@@ -45,7 +45,7 @@ describe MangoPay::PayIn::PreAuthorized::Direct, type: :feature do
     it 'refunds a payin' do
       payin = new_payin_preauthorized_direct
       sleep(2)
-      refund = MangoPay::PayIn.refund(payin['Id'], {AuthorId: payin['AuthorId']})
+      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')
@@ -66,26 +66,53 @@ describe MangoPay::PayIn::PreAuthorized::Direct, type: :feature do
       wallets_reload_and_check_amounts(wlt, 1000)
 
       # refund the payin
-      refund = MangoPay::PayIn.refund(payin['Id'], {AuthorId: payin['AuthorId']})
+      refund = MangoPay::PayIn.refund(payin['Id'], { AuthorId: payin['AuthorId'] })
       wallets_reload_and_check_amounts(wlt, 0)
     end
   end
 
-    # this flow is tested manually for the moment
-=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'])
+  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'])
+        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'])
+        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
 end

data/spec/mangopay/payout_bankwire_spec.rb

@@ -32,13 +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, 10000)
+      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('001001')
-      expect(fetched['ResultMessage']).to eq('Unsufficient wallet balance')
+      expect(fetched['ResultCode']).to eq('002998')
+      # expect(fetched['ResultMessage']).to eq('Unsufficient wallet balance')
     end
   end
 

data/spec/mangopay/preauthorization_spec.rb

@@ -14,7 +14,7 @@ describe MangoPay::PreAuthorization do
       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')
+      # expect(created['Requested3DSVersion']).to eq('V2_1')
     end
   end
 

data/spec/mangopay/recipient_spec.rb

@@ -5,7 +5,7 @@ describe MangoPay::Recipient do
     it 'creates a new recipient' do
       recipient = new_recipient
       assert_recipient(recipient)
-      expect(recipient['PendingUserAction']).not_to be_nil
+      expect(recipient['Status']).to eq('PENDING')
     end
   end
 
@@ -18,19 +18,37 @@ describe MangoPay::Recipient do
   end
 
   describe 'GET User Recipients' do
-    it 'fetches a recipient' do
-      john = create_new_natural_user_sca_owner
+    it 'fetches recipients without query param' do
+      john = create_new_natural_user_sca_payer
       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_payer
+      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_payer
+      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')
+      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
@@ -42,10 +60,11 @@ describe MangoPay::Recipient do
       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')
+      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
@@ -57,6 +76,7 @@ describe MangoPay::Recipient do
       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
 
@@ -72,7 +92,7 @@ describe MangoPay::Recipient do
   describe 'VALIDATE' do
     it 'validates a recipient' do
       recipient = define_new_recipient
-      john = create_new_natural_user_sca_owner
+      john = create_new_natural_user_sca_payer
       # it should pass
       MangoPay::Recipient.validate(recipient, john['Id'])
 
@@ -110,4 +130,5 @@ def assert_recipient(recipient)
   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

data/spec/mangopay/recurring_payin_spec.rb

@@ -73,7 +73,7 @@ describe MangoPay::PayIn::RecurringPayments, type: :feature do
       expect(cit).not_to be_nil
 
       update = MangoPay::PayIn::RecurringPayments::Recurring.update(id, {
-        Status: 'Ended'
+        Status: 'ENDED'
       })
 
       expect(update).not_to be_nil
@@ -140,7 +140,7 @@ describe MangoPay::PayIn::RecurringPayments, type: :feature do
       )
 
       expect(cit).not_to be_nil
-      expect(cit['Status']).to eq('CREATED')
+      # expect(cit['Status']).to eq('CREATED')
       expect(cit['PaymentType']).to eq('PAYPAL')
       expect(cit['ExecutionType']).to eq('WEB')
     end
@@ -214,7 +214,7 @@ describe MangoPay::PayIn::RecurringPayments, type: :feature do
       )
 
       expect(cit).not_to be_nil
-      expect(cit['Status']).to eq('CREATED')
+      # expect(cit['Status']).to eq('CREATED')
       expect(cit['PaymentType']).to eq('PAYPAL')
       expect(cit['ExecutionType']).to eq('WEB')
     end

data/spec/mangopay/report_v2_spec.rb

@@ -0,0 +1,117 @@
+describe MangoPay::ReportV2 do
+
+  def create
+    params = {
+      "Tag": "Created using the Mangopay API Postman collection",
+      "DownloadFormat": "CSV",
+      "ReportType": "COLLECTED_FEES",
+      "AfterDate": 1740787200,
+      "BeforeDate": 1743544740
+    }
+    MangoPay::ReportV2.create(params)
+  end
+
+  describe 'CREATE' do
+    it 'creates a report v2' do
+      created = create
+      expect(created['Id']).to_not be_nil
+      expect(created['Status']).to eq("PENDING")
+    end
+
+    it 'creates an intent report' do
+      params = {
+        "DownloadFormat": "CSV",
+        "ReportType": "ECHO_INTENT",
+        "AfterDate": 1748782023,
+        "BeforeDate": 1753102013,
+        "Filters": {
+          "PaymentMethod": "PAYPAL",
+          "Status": "CAPTURED",
+          "Type": "PAYIN"
+        },
+        "Columns": %w[Id Status Amount Currency FeesAmount FeesCurrency Type PaymentMethod BuyerId SellerId]
+      }
+
+      created = MangoPay::ReportV2.create(params)
+      expect(created['Id']).to_not be_nil
+      expect(created['Status']).to eq("PENDING")
+      expect(created['ReportType']).to eq("ECHO_INTENT")
+    end
+
+    it 'creates an intent actions report' do
+      params = {
+        "DownloadFormat": "CSV",
+        "ReportType": "ECHO_INTENT_ACTION",
+        "AfterDate": 1748782023,
+        "BeforeDate": 1753102013,
+        "Filters": {
+          "PaymentMethod": "PAYPAL",
+          "Status": "CAPTURED",
+          "Type": "PAYIN"
+        },
+        "Columns": %w[IntentId Id ExternalProcessingDate ExternalProviderReference ExternalMerchantReference Status Amount Currency FeesAmount FeesCurrency Type PaymentMethod BuyerId SellerId]
+      }
+
+      created = MangoPay::ReportV2.create(params)
+      expect(created['Id']).to_not be_nil
+      expect(created['Status']).to eq("PENDING")
+      expect(created['ReportType']).to eq("ECHO_INTENT_ACTION")
+    end
+
+    it 'creates settlement report' do
+      params = {
+        "Tag": "Creating a report using new Mangopay system",
+        "DownloadFormat": "CSV",
+        "ReportType": "ECHO_SETTLEMENT",
+        "AfterDate": 1748782023,
+        "BeforeDate": 1753102013,
+        "Filters": {
+          "Status": "RECONCILED",
+          "ExternalProviderName": "PAYPAL"
+        },
+        "Columns": %w[Id CreationDate FileName SettlementCurrency Status SettledTransactionCount UnsettledTransactionCount SettledAmount DeclaredAmount DeficitAmount]
+      }
+
+      created = MangoPay::ReportV2.create(params)
+      expect(created['Id']).to_not be_nil
+      expect(created['Status']).to eq("PENDING")
+      expect(created['ReportType']).to eq("ECHO_SETTLEMENT")
+    end
+  end
+
+  it 'creates split report' do
+    params = {
+      "Tag": "Creating a report using new Mangopay system",
+      "DownloadFormat": "CSV",
+      "ReportType": "ECHO_SPLIT",
+      "AfterDate": 1748782023,
+      "BeforeDate": 1753102013,
+      "Filters": {
+        "Status": "COMPLETED",
+        "IntentId": "int_0197f975-63f6-714e-8fc6-4451e128170f",
+        "Scheduled": false
+      },
+      "Columns": %w[Id IntentId AuthorId Amount Currency FeesAmount FeesCurrency Status Description CreditedWalletId DebitedWalletId Scheduled CreationDate ExecutionDate]
+    }
+
+    created = MangoPay::ReportV2.create(params)
+    expect(created['Id']).to_not be_nil
+    expect(created['Status']).to eq("PENDING")
+    expect(created['ReportType']).to eq("ECHO_SPLIT")
+  end
+
+  describe 'GET' do
+    it 'gets a report' do
+      created = create
+      fetched = MangoPay::ReportV2.get(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+    end
+
+    it 'gets all the reports' do
+      reports = MangoPay::ReportV2.get_all
+      expect(reports).to be_kind_of(Array)
+      expect(reports).not_to be_empty
+    end
+  end
+
+end

data/spec/mangopay/settlement_sample.csv

@@ -0,0 +1,8 @@
+IntentId,ExternalProviderReference,ExternalPaymentMethod,ExternalTransactionType,ExternalTransactionStatus,ExternalProcessingDate,Amount,Currency,ExternalInitialReference,ExternalProviderFees
+int_0197b19d-ee51-7b60-84cb-207491cf383a,6TU984332A894613W,PAYPAL,PAYMENT,SETTLED,19-06-2025,1000,EUR,,0
+,,,,,,,,,
+SettlementDate,19-06-2025,,,,,,,,
+ExternalProviderName,Paypal,,,,,,,,
+TotalSettlementFeesAmount,0,,,,,,,,
+TotalSettlementAmount,1000,,,,,,,,
+SettlementCurrency,EUR,,,,,,,,

data/spec/mangopay/settlement_spec.rb

@@ -0,0 +1,38 @@
+describe MangoPay::Settlement do
+
+  let!(:settlement) do
+    create_settlement_if_needed
+  end
+
+  def create_settlement_if_needed
+    @settlement ||= begin
+                      file_path = File.expand_path('settlement_sample.csv', __dir__)
+                      file = File.binread(file_path)
+                      MangoPay::Settlement.upload(file)
+                    end
+  end
+
+  describe 'UPLOAD' do
+    it 'uploads the file' do
+      expect(@settlement['Status']).to eq('UPLOADED')
+    end
+  end
+
+  describe 'GET' do
+    it 'fetches the file' do
+      fetched = MangoPay::Settlement.get(@settlement['SettlementId'])
+      expect(fetched['Status']).to eq('UPLOADED')
+    end
+  end
+
+  describe 'UPDATE' do
+    it 'updates the file' do
+      file_path = File.expand_path('settlement_sample.csv', __dir__)
+      file = File.binread(file_path)
+      before_update = MangoPay::Settlement.upload(file)
+      expect(before_update['Status']).to eq('UPLOADED')
+      updated = MangoPay::Settlement.update(before_update['SettlementId'], file)
+      expect(updated['Status']).to eq('UPLOADED')
+    end
+  end
+end

data/spec/mangopay/shared_resources.rb

@@ -27,14 +27,15 @@ shared_context 'users' do
       Nationality: 'FR',
       CountryOfResidence: 'FR',
       Occupation: 'Worker',
-      IncomeRange: 1
+      IncomeRange: 1,
+      TermsAndConditionsAccepted: true
     }
   end
 
   def define_new_natural_user_sca_payer
     {
       "UserCategory": "PAYER",
-      "TermsAndConditionsAccepted": false,
+      "TermsAndConditionsAccepted": true,
       "FirstName": "Alex",
       "LastName": "Smith",
       "Email": "alex.smith@example.com",
@@ -79,7 +80,7 @@ shared_context 'users' do
   def define_new_legal_user_sca_payer
     {
       "UserCategory": "PAYER",
-      "TermsAndConditionsAccepted": false,
+      "TermsAndConditionsAccepted": true,
       "LegalPersonType": "SOLETRADER",
       "Name": "Alex Smith",
       "Email": "alex.smith.services@example.com",
@@ -193,7 +194,8 @@ shared_context 'users' do
       CompanyNumber: 'LU123456789',
       Statute: '',
       ProofOfRegistration: '',
-      ShareholderDeclaration: ''
+      ShareholderDeclaration: '',
+      TermsAndConditionsAccepted: true
     )
   end
 end
@@ -372,6 +374,18 @@ shared_context 'payins' do
     )
   end
 
+  let(:new_payin_payconiq_web_legacy) do
+    MangoPay::PayIn::Payconiq::Web.create_legacy(
+      AuthorId: new_natural_user['Id'],
+      CreditedWalletId: new_wallet['Id'],
+      DebitedFunds: { Currency: 'EUR', Amount: 100 },
+      Fees: { Currency: 'EUR', Amount: 0 },
+      ReturnURL: MangoPay.configuration.root_url,
+      Country: "BE",
+      Tag: 'Custom Meta'
+    )
+  end
+
   ###############################################
   # applepay/direct
   ###############################################
@@ -740,6 +754,37 @@ shared_context 'payins' do
     )
   end
 
+  ###############################################
+  # Bizum/web
+  ###############################################
+  let(:new_payin_bizum_web_with_phone) do
+    user = new_natural_user
+    wallet = new_wallet
+    bizum = define_new_bizum(user, wallet, '+34700000000', nil)
+    MangoPay::PayIn::Bizum::Web.create(bizum)
+  end
+
+  let(:new_payin_bizum_web_with_return_url) do
+    user = new_natural_user
+    wallet = new_wallet
+    bizum = define_new_bizum(user, wallet, nil, 'https://docs.mangopay.com/please-ignore')
+    MangoPay::PayIn::Bizum::Web.create(bizum)
+  end
+
+  def define_new_bizum(user, wallet, phone, return_url)
+    {
+      AuthorId: user['Id'],
+      CreditedWalletId: wallet['Id'],
+      DebitedFunds: { Currency: 'EUR', Amount: 400 },
+      Fees: { Currency: 'EUR', Amount: 1 },
+      StatementDescriptor: "test bizum",
+      Phone: phone,
+      ReturnUrl: return_url,
+      Tag: 'Test PayIn/Bizum/Web',
+      ProfilingAttemptReference: nil
+    }
+  end
+
   ###############################################
   # Twint/web
   ###############################################
@@ -936,6 +981,28 @@ shared_context 'payins' do
     )
   end
 
+  def create_new_deposit_pre_authorized_pay_in_prior_to_complement(deposit_id, author_id, credited_wallet_id)
+    MangoPay::PayIn::PreAuthorized::Direct.create_deposit_preauthorized_pay_in_prior_to_complement(
+      AuthorId: author_id,
+      CreditedWalletId: credited_wallet_id,
+      DebitedFunds: { Currency: 'EUR', Amount: 1000 },
+      Fees: { Currency: 'EUR', Amount: 0 },
+      DepositId: deposit_id,
+      Tag: 'lorem ipsum'
+    )
+  end
+
+  def create_new_deposit_pre_authorized_pay_in_complement(deposit_id, author_id, credited_wallet_id)
+    MangoPay::PayIn::PreAuthorized::Direct.create_deposit_preauthorized_pay_in_complement(
+      AuthorId: author_id,
+      CreditedWalletId: credited_wallet_id,
+      DebitedFunds: { Currency: 'EUR', Amount: 1000 },
+      Fees: { Currency: 'EUR', Amount: 0 },
+      DepositId: deposit_id,
+      Tag: 'lorem ipsum'
+    )
+  end
+
   ###############################################
   # bankwire/direct
   ###############################################
@@ -1239,7 +1306,7 @@ end
 shared_context 'recipient' do
   include_context 'users'
 
-  let(:new_recipient) { create_new_recipient(create_new_natural_user_sca_owner['Id']) }
+  let(:new_recipient) { create_new_recipient(create_new_natural_user_sca_payer['Id']) }
 
   def create_new_recipient(user_id)
     MangoPay::Recipient.create(define_new_recipient, user_id)
@@ -1251,6 +1318,7 @@ shared_context 'recipient' do
       "PayoutMethodType": "LocalBankTransfer",
       "RecipientType": "Individual",
       "Currency": "GBP",
+      "Country": "GB",
       "IndividualRecipient": {
         "FirstName": "Alex",
         "LastName": "Smith",
@@ -1269,4 +1337,44 @@ shared_context 'recipient' do
       }
     }
   end
+end
+
+shared_context 'intents' do
+  include_context 'users'
+
+  let(:new_payin_intent_authorization) { create_new_payin_intent_authorization(create_new_natural_user_sca_payer) }
+
+  def create_new_payin_intent_authorization(user)
+    MangoPay::PayIn::PayInIntent::Authorization.create(define_new_payin_intent_authorization(user))
+  end
+
+  def define_new_payin_intent_authorization(user)
+    wallet = create_new_wallet(user)
+    {
+      "Amount": 1000,
+      "Currency": "EUR",
+      "ExternalData": {
+        "ExternalProcessingDate": 1728133765,
+        "ExternalProviderReference": SecureRandom.uuid,
+        "ExternalMerchantReference": "Order-xyz-35e8490e-2ec9-4c82-978e-c712a3f5ba16",
+        "ExternalProviderName": "Stripe",
+        "ExternalProviderPaymentMethod": "PAYPAL"
+      },
+      "Buyer": {
+        "Id": user['Id']
+      },
+      "LineItems": [
+        {
+          "Seller": {
+            "AuthorId": user['Id'],
+            "WalletId": wallet['Id'],
+            "TransferDate": 1728133765
+          },
+          "Sku": "item-123456",
+          "Quantity": 1,
+          "UnitAmount": 1000,
+        }
+      ]
+    }
+  end
 end

data/spec/mangopay/user_spec.rb

@@ -54,14 +54,16 @@ describe MangoPay::User do
   describe 'UPDATE' do
     it 'updates a natural user' do
       updated_user = MangoPay::NaturalUser.update(new_natural_user['Id'] ,{
-        FirstName: 'Jack'
+        FirstName: 'Jack',
+        TermsAndConditionsAccepted: true
       })
       expect(updated_user['FirstName']).to eq('Jack')
     end
 
     it 'updates a legal user' do
       updated_user = MangoPay::LegalUser.update(new_legal_user['Id'], {
-        LegalRepresentativeFirstName: 'Jack'
+        LegalRepresentativeFirstName: 'Jack',
+        TermsAndConditionsAccepted: true
       })
       expect(updated_user['LegalRepresentativeFirstName']).to eq('Jack')
     end
@@ -85,7 +87,8 @@ describe MangoPay::User do
     it 'updates a SCA natural user' do
       user = new_natural_user_sca_owner
       updated_user = MangoPay::NaturalUserSca.update(user['Id'] ,{
-        FirstName: 'Jack'
+        FirstName: 'Jack',
+        TermsAndConditionsAccepted: true
       })
       fetched = MangoPay::NaturalUserSca.fetch(user['Id'])
       expect(updated_user['FirstName']).to eq('Jack')
@@ -97,7 +100,8 @@ describe MangoPay::User do
       legal_representative = user['LegalRepresentative']
       legal_representative['FirstName'] = 'Jack'
       updated_user = MangoPay::LegalUserSca.update(user['Id'] ,{
-        LegalRepresentative: legal_representative
+        LegalRepresentative: legal_representative,
+        TermsAndConditionsAccepted: true
       })
       fetched = MangoPay::LegalUserSca.fetch(user['Id'])
       expect(updated_user['LegalRepresentative']['FirstName']).to eq('Jack')
@@ -157,6 +161,18 @@ describe MangoPay::User do
     end
   end
 
+  describe 'MANAGE CONSENT' do
+    it 'manages consent' do
+      user = new_natural_user
+
+      enrollment_result = MangoPay::User.enroll_sca(user['Id'])
+      expect(enrollment_result["PendingUserAction"]["RedirectUrl"]).not_to be_nil
+
+      consent_result = MangoPay::User.manage_consent(user['Id'])
+      expect(consent_result["PendingUserAction"]["RedirectUrl"]).not_to be_nil
+    end
+  end
+
   describe 'FETCH' do
     it 'fetches all the users' do
       users = MangoPay::User.fetch()
@@ -399,4 +415,30 @@ describe MangoPay::User do
       expect(closed['UserStatus']).to eq('CLOSED')
     end
   end
+
+  describe 'Validate User Data Format' do
+    it 'validates successfully' do
+      validation = {
+        "CompanyNumber": {
+          "CompanyNumber": "AB123456",
+          "CountryCode": "IT"
+        }
+      }
+      result = MangoPay::User.validate_data_format(validation)
+      expect(result['CompanyNumber']).not_to be_nil
+    end
+
+    it 'validates with error' do
+      validation = {
+        "CompanyNumber": {
+          "CompanyNumber": "123"
+        }
+      }
+      expect { MangoPay::User.validate_data_format(validation) }.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
 end