mangopay4-ruby-sdk 3.44.0

data/spec/mangopay/transaction_spec.rb

@@ -0,0 +1,59 @@
+describe MangoPay::Transaction do
+  include_context 'wallets'
+  include_context 'payins'
+  include_context 'payouts'
+
+  describe 'FETCH' do
+
+    it 'fetches empty list of transactions if no transactions done' do
+      transactions = MangoPay::Transaction.fetch(new_wallet['Id'])
+      expect(transactions).to be_kind_of(Array)
+      expect(transactions).to be_empty
+    end
+
+    it 'fetches list with single transaction after payin done' do
+      payin = new_payin_card_direct
+      transactions = MangoPay::Transaction.fetch(new_wallet['Id'])
+      expect(transactions).to be_kind_of(Array)
+      expect(transactions.count).to eq 1
+      expect(transactions.first['Id']).to eq payin['Id']
+    end
+
+    it 'fetches list with two transactions after payin and payout done' do
+      payin = new_payin_card_direct
+      payout = create_new_payout_bankwire(payin)
+      # wait for the transactions to be created
+      sleep(2)
+      transactions = MangoPay::Transaction.fetch(new_wallet['Id'])
+
+      expect(transactions).to be_kind_of(Array)
+      expect(transactions.count).to eq 2
+
+      transactions_ids = transactions.map {|t| t['Id']}
+      expect(transactions_ids).to include payin['Id']
+      expect(transactions_ids).to include payout['Id']
+    end
+
+    it 'accepts filtering params' do
+      payin = new_payin_card_direct
+      payout = create_new_payout_bankwire(payin)
+      wallet_id = new_wallet['Id']
+
+      # wait for the transactions to be created
+      sleep(2)
+
+      by_nature_reg = MangoPay::Transaction.fetch(wallet_id, {'Nature' => 'REGULAR'})
+      by_nature_ref = MangoPay::Transaction.fetch(wallet_id, {'Nature' => 'REFUND'})
+      expect(by_nature_reg.count).to eq 2
+      expect(by_nature_ref.count).to eq 0
+
+      by_type_pyin  = MangoPay::Transaction.fetch(wallet_id, {'Type' => 'PAYIN'})
+      by_type_pyout = MangoPay::Transaction.fetch(wallet_id, {'Type' => 'PAYOUT'})
+      expect(by_type_pyin.count).to eq 1
+      expect(by_type_pyout.count).to eq 1
+      expect(by_type_pyin.first['Id']).to eq payin['Id']
+      expect(by_type_pyout.first['Id']).to eq payout['Id']
+    end
+
+  end
+end

data/spec/mangopay/transfer_spec.rb

@@ -0,0 +1,77 @@
+describe MangoPay::Transfer, type: :feature do
+  include_context 'wallets'
+  include_context 'payins'
+  include_context 'transfers'
+
+  def check_type_and_status(trans)
+    expect(trans['Type']).to eq('TRANSFER')
+    expect(trans['Nature']).to eq('REGULAR')
+
+    # SUCCEEDED
+    expect(trans['Status']).to eq('SUCCEEDED')
+    expect(trans['ResultCode']).to eq('000000')
+    expect(trans['ResultMessage']).to eq('Success')
+    expect(trans['ExecutionDate']).to be > 0
+  end
+
+  describe 'CREATE' do
+    it 'creates a new Transfer' do
+      created = new_transfer
+      expect(created['Id']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a Transfer' do
+      created = new_transfer
+      fetched = MangoPay::Transfer.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
+    end
+  end
+
+  describe 'REFUND' do
+    it 'refunds a transfer' do
+      trans = new_transfer
+      refund = MangoPay::Transfer.refund(trans['Id'], {AuthorId: trans['AuthorId']})
+      expect(refund['Id']).not_to be_nil
+      expect(refund['Status']).to eq('SUCCEEDED')
+      expect(refund['Type']).to eq('TRANSFER')
+      expect(refund['Nature']).to eq('REFUND')
+      expect(refund['InitialTransactionType']).to eq('TRANSFER')
+      expect(refund['InitialTransactionId']).to eq(trans['Id'])
+      expect(refund['DebitedWalletId']).to eq(trans['CreditedWalletId'])
+      expect(refund['CreditedWalletId']).to eq(trans['DebitedWalletId'])
+    end
+  end
+
+  describe 'CASH FLOW' do
+    it 'changes balances correctly' do
+      wlt1 = new_wallet
+      wlt2 = new_wallet_legal
+      wallets_check_amounts(wlt1, 0, wlt2, 0)
+
+      # payin: feed wlt1 with money
+      create_new_payin_card_direct(wlt1, 1000)
+      wallets_reload_and_check_amounts(wlt1, 1000, wlt2, 0)
+
+      # trnasfer wlt1 => wlt2
+      trans = create_new_transfer(wlt1, wlt2, 600)
+      wallets_reload_and_check_amounts(wlt1, 400, wlt2, 600)
+
+      # refund the trnasfer
+      refund = MangoPay::Transfer.refund(trans['Id'], {AuthorId: trans['AuthorId']})
+      wallets_reload_and_check_amounts(wlt1, 1000, wlt2, 0)
+    end
+  end
+
+  describe 'FETCH Refunds' do
+    it "fetches a transfer's refunds" do
+      transfer = new_transfer
+      refunds = MangoPay::Transfer.refunds(transfer['Id'])
+      expect(refunds).to be_an(Array)
+    end
+  end
+end

data/spec/mangopay/ubo_declaration_spec.rb

@@ -0,0 +1,44 @@
+describe MangoPay::UboDeclaration do
+  include_context 'users'
+  include_context 'ubo'
+
+  describe 'FETCH' do
+    it 'can fetch a UBO declaration' do
+      legal_user = new_legal_user
+
+      ubo_declaration = MangoPay::UboDeclaration.create(legal_user['Id'])
+
+      ubo_declaration_byId = MangoPay::UboDeclaration.fetch(legal_user['Id'], ubo_declaration['Id'])
+
+      expect(ubo_declaration).not_to be_nil
+      expect(ubo_declaration_byId).not_to be_nil
+    end
+
+    it 'fetches ubo declaration just by id' do
+      legal_user = new_legal_user
+
+      ubo_declaration = MangoPay::UboDeclaration.create(legal_user['Id'], nil)
+
+      ubo_declaration_byId = MangoPay::UboDeclaration.fetch(nil, ubo_declaration['Id'], nil)
+
+      expect(ubo_declaration).not_to be_nil
+      expect(ubo_declaration_byId).not_to be_nil
+    end
+
+    describe 'UPDATE' do
+      it 'can update a UBO declaration' do
+        legal_user = new_legal_user
+        ubo_declaration = MangoPay::UboDeclaration.create(legal_user['Id'])
+        ubo_declaration['Status'] = 'VALIDATION_ASKED'
+
+        ubo = new_ubo(legal_user, ubo_declaration)
+
+        ubo_declaration['Ubos'] = [ubo]
+        ubo_declaration = MangoPay::UboDeclaration.update(legal_user['Id'], ubo_declaration['Id'], ubo_declaration)
+
+        expect(ubo_declaration).not_to be_nil
+        expect(ubo_declaration['Status']).to eq 'VALIDATION_ASKED'
+      end
+    end
+  end
+end

data/spec/mangopay/ubo_spec.rb

@@ -0,0 +1,39 @@
+describe MangoPay::Ubo do
+  include_context 'users'
+  include_context 'ubo'
+
+  describe 'FETCH' do
+    it 'can fetch a Ubo' do
+      legal_user = new_legal_user
+      ubo_declaration = MangoPay::UboDeclaration.create(legal_user['Id'])
+      ubo = new_ubo(legal_user, ubo_declaration)
+      result = MangoPay::Ubo.fetch(legal_user['Id'], ubo_declaration['Id'], ubo['Id'])
+      expect(result).not_to be_nil
+      expect(result['Id']).equal? ubo['Id']
+    end
+  end
+
+  describe 'CREATE' do
+    it 'can create a new Ubo' do
+      legal_user = new_legal_user
+      ubo_declaration = MangoPay::UboDeclaration.create(legal_user['Id'])
+      result = new_ubo(legal_user, ubo_declaration)
+      expect(result).not_to be_nil
+    end
+  end
+
+  describe 'UPDATE' do
+    it 'can update a Ubo' do
+      legal_user = new_legal_user
+      ubo_declaration = MangoPay::UboDeclaration.create(legal_user['Id'])
+      ubo = new_ubo(legal_user, ubo_declaration)
+      ubo['FirstName'] = 'Santa'
+      ubo['LastName'] = 'Clause'
+
+      result = MangoPay::Ubo.update(legal_user['Id'], ubo_declaration['Id'], ubo['Id'], ubo)
+      expect(result).not_to be_nil
+      expect(result['FirstName']).equal? ubo['FirstName']
+      expect(result['LastName']).equal? ubo['LastName']
+    end
+  end
+end

data/spec/mangopay/user_spec.rb

@@ -0,0 +1,444 @@
+describe MangoPay::User do
+  include_context 'users'
+  include_context 'payins'
+  include_context 'payouts'
+  include_context 'wallets'
+  include_context 'kyc_documents'
+
+  describe 'CREATE' do
+    it 'creates a new natural user' do
+      expect(new_natural_user["FirstName"]).to eq('John')
+    end
+
+    it 'creates a new legal user' do
+      expect(new_legal_user["LegalRepresentativeFirstName"]).to eq('John')
+    end
+
+    it 'creates a new legal user' do
+      expect(new_legal_user["CompanyNumber"]).to eq('LU123456789')
+    end
+  end
+
+  describe 'CREATE SCA' do
+    it 'creates a new SCA natural user payer' do
+      user = new_natural_user_sca_payer
+      expect(user["FirstName"]).to eq('Alex')
+      expect(user["UserCategory"]).to eq('PAYER')
+      expect(user["UserStatus"]).to eq('ACTIVE')
+    end
+
+    it 'creates a new SCA natural user owner' do
+      user = new_natural_user_sca_owner
+      expect(user["FirstName"]).to eq('Alex')
+      expect(user["UserCategory"]).to eq('OWNER')
+      expect(user["UserStatus"]).to eq('PENDING_USER_ACTION')
+      expect(user["PendingUserAction"]["RedirectUrl"]).not_to be_nil
+    end
+
+    it 'creates a new SCA legal user payer' do
+      user = new_legal_user_sca_payer
+      expect(user["Name"]).to eq('Alex Smith')
+      expect(user["UserCategory"]).to eq('PAYER')
+      expect(user["UserStatus"]).to eq('ACTIVE')
+    end
+
+    it 'creates a new SCA legal user owner' do
+      user = new_legal_user_sca_owner
+      expect(user["Name"]).to eq('Alex Smith')
+      expect(user["UserCategory"]).to eq('OWNER')
+      expect(user["UserStatus"]).to eq('PENDING_USER_ACTION')
+      expect(user["PendingUserAction"]["RedirectUrl"]).not_to be_nil
+    end
+  end
+
+  describe 'UPDATE' do
+    it 'updates a natural user' do
+      updated_user = MangoPay::NaturalUser.update(new_natural_user['Id'] ,{
+        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',
+        TermsAndConditionsAccepted: true
+      })
+      expect(updated_user['LegalRepresentativeFirstName']).to eq('Jack')
+    end
+
+    it 'updates a natural user terms and conditions accepted' do
+      updated_user = MangoPay::NaturalUser.update(new_natural_user['Id'] ,{
+        TermsAndConditionsAccepted: true
+      })
+      expect(updated_user['TermsAndConditionsAccepted']).to eq(true)
+    end
+
+    it 'updates a legal user terms and conditions accepted' do
+      updated_user = MangoPay::LegalUser.update(new_legal_user['Id'], {
+        TermsAndConditionsAccepted: true
+      })
+      expect(updated_user['TermsAndConditionsAccepted']).to eq(true)
+    end
+  end
+
+  describe 'UPDATE SCA' do
+    it 'updates a SCA natural user' do
+      user = new_natural_user_sca_owner
+      updated_user = MangoPay::NaturalUserSca.update(user['Id'] ,{
+        FirstName: 'Jack',
+        TermsAndConditionsAccepted: true
+      })
+      fetched = MangoPay::NaturalUserSca.fetch(user['Id'])
+      expect(updated_user['FirstName']).to eq('Jack')
+      expect(updated_user['FirstName']).to eq(fetched['FirstName'])
+    end
+
+    it 'updates a SCA legal user' do
+      user = new_legal_user_sca_owner
+      legal_representative = user['LegalRepresentative']
+      legal_representative['FirstName'] = 'Jack'
+      updated_user = MangoPay::LegalUserSca.update(user['Id'] ,{
+        LegalRepresentative: legal_representative,
+        TermsAndConditionsAccepted: true
+      })
+      fetched = MangoPay::LegalUserSca.fetch(user['Id'])
+      expect(updated_user['LegalRepresentative']['FirstName']).to eq('Jack')
+      expect(updated_user['LegalRepresentative']['FirstName']).to eq(fetched['LegalRepresentative']['FirstName'])
+    end
+  end
+
+  describe 'CATEGORIZE SCA' do
+    it 'transitions SCA natural user Payer to Owner' do
+      user = new_natural_user_sca_payer
+      categorized = MangoPay::NaturalUserSca.categorize(user['Id'] ,{
+        "UserCategory": "OWNER",
+        "TermsAndConditionsAccepted": true,
+        "Birthday": 652117514,
+        "Nationality": "FR",
+        "CountryOfResidence": "FR"
+      })
+      fetched = MangoPay::NaturalUserSca.fetch(user['Id'])
+      expect(user['UserCategory']).to eq('PAYER')
+      expect(categorized['UserCategory']).to eq('OWNER')
+      expect(fetched['UserCategory']).to eq('OWNER')
+    end
+
+    it 'transitions SCA legal user Payer to Owner' do
+      user = new_legal_user_sca_payer
+      categorized = MangoPay::LegalUserSca.categorize(user['Id'] ,{
+        "UserCategory": "OWNER",
+        "TermsAndConditionsAccepted": true,
+        "LegalRepresentative": {
+          "Birthday": 652117514,
+          "Nationality": "FR",
+          "CountryOfResidence": "FR",
+          "Email": "alex.smith@example.com"
+        },
+        "HeadquartersAddress": {
+          "AddressLine1": "3 rue de la Cité",
+          "AddressLine2": "Appartement 7",
+          "City": "Paris",
+          "Region": "Île-de-France",
+          "PostalCode": "75004",
+          "Country": "FR"
+        },
+        "CompanyNumber": "123456789"
+      })
+      fetched = MangoPay::LegalUserSca.fetch(user['Id'])
+      expect(user['UserCategory']).to eq('PAYER')
+      expect(categorized['UserCategory']).to eq('OWNER')
+      expect(fetched['UserCategory']).to eq('OWNER')
+    end
+  end
+
+  describe 'ENROLL SCA' do
+    it 'enrolls user' do
+      user = new_natural_user
+      enrollment_result = MangoPay::User.enroll_sca(user['Id'])
+      expect(enrollment_result["PendingUserAction"]["RedirectUrl"]).not_to be_nil
+    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()
+      expect(users).to be_kind_of(Array)
+      expect(users).not_to be_empty
+    end
+
+    it 'fetches a legal user using the User module' do
+      legal_user = MangoPay::User.fetch(new_legal_user['Id'])
+      expect(legal_user['Id']).to eq(new_legal_user['Id'])
+    end
+
+    it 'fetches a natural user using the User module' do
+      natural_user = MangoPay::User.fetch(new_natural_user['Id'])
+      expect(natural_user['Id']).to eq(new_natural_user['Id'])
+    end
+
+    it 'fetches a legal user' do
+      user = MangoPay::LegalUser.fetch(new_legal_user['Id'])
+      expect(user['Id']).to eq(new_legal_user['Id'])
+    end
+
+    it 'fetches a natural user' do
+      user = MangoPay::NaturalUser.fetch(new_natural_user['Id'])
+      expect(user['Id']).to eq(new_natural_user['Id'])
+    end
+  end
+
+  describe 'FETCH SCA' do
+    it 'fetches a SCA legal user using the User module' do
+      user = new_legal_user_sca_owner
+      fetched = MangoPay::User.fetch_sca(new_legal_user_sca_owner['Id'])
+      expect(fetched['Id']).to eq(user['Id'])
+    end
+
+    it 'fetches a SCA natural user using the User module' do
+      user = new_natural_user_sca_owner
+      fetched = MangoPay::User.fetch_sca(user['Id'])
+      expect(fetched['Id']).to eq(user['Id'])
+    end
+
+    it 'fetches a SCA legal user' do
+      user = new_legal_user_sca_owner
+      fetched = MangoPay::LegalUserSca.fetch(user['Id'])
+      expect(fetched['Id']).to eq(user['Id'])
+    end
+
+    it 'fetches a SCA natural user' do
+      user = new_natural_user_sca_owner
+      fetched = MangoPay::NaturalUserSca.fetch(user['Id'])
+      expect(fetched['Id']).to eq(user['Id'])
+    end
+  end
+
+  describe 'FETCH TRANSACTIONS' do
+    it 'fetches empty list of transactions if no transactions done' do
+      transactions = MangoPay::User.transactions(new_natural_user['Id'])
+      expect(transactions).to be_kind_of(Array)
+      expect(transactions).to be_empty
+    end
+
+    it 'fetches list with single transaction after payin done' do
+      payin = new_payin_card_direct
+      transactions = MangoPay::User.transactions(new_natural_user['Id'])
+      expect(transactions).to be_kind_of(Array)
+      expect(transactions.count).to eq 1
+      expect(transactions.first['Id']).to eq payin['Id']
+    end
+
+    it 'fetches list with two transactions after payin and payout done' do
+      payin = new_payin_card_direct
+      payout = create_new_payout_bankwire(payin)
+      # wait for the transactions to be created
+      sleep(2)
+      transactions = MangoPay::User.transactions(new_natural_user['Id'])
+
+      expect(transactions).to be_kind_of(Array)
+      expect(transactions.count).to eq 2
+
+      transactions_ids = transactions.map {|t| t['Id']}
+      expect(transactions_ids).to include payin['Id']
+      expect(transactions_ids).to include payout['Id']
+    end
+
+    it 'fetches transactions sca' do
+      begin
+        MangoPay::User.transactions(new_natural_user['Id'], {'ScaContext': 'USER_PRESENT'})
+      rescue MangoPay::ResponseError => ex
+        expect(ex.details['RedirectUrl']).not_to be_nil
+      end
+    end
+  end
+
+  describe 'FETCH WALLETS' do
+    it 'fetches empty list of wallets if no wallets created' do
+      wallets = MangoPay::User.wallets(new_natural_user['Id'])
+      expect(wallets).to be_kind_of(Array)
+      expect(wallets).to be_empty
+    end
+
+    it 'fetches list with single wallet after created' do
+      wallet = new_wallet
+      wallets = MangoPay::User.wallets(new_natural_user['Id'])
+      expect(wallets).to be_kind_of(Array)
+      expect(wallets.count).to eq 1
+      expect(wallets.first['Id']).to eq wallet['Id']
+    end
+
+    it 'fetches wallets sca' do
+      begin
+        MangoPay::User.wallets(new_natural_user['Id'], {'ScaContext': 'USER_PRESENT'})
+      rescue MangoPay::ResponseError => ex
+        expect(ex.details['RedirectUrl']).not_to be_nil
+      end
+    end
+  end
+
+  describe 'FETCH CARDS' do
+    it 'fetches empty list of cards if no cards created' do
+      cards = MangoPay::User.cards(new_natural_user['Id'])
+      expect(cards).to be_kind_of(Array)
+      expect(cards).to be_empty
+    end
+
+    it 'fetches list with single card after created' do
+      card = new_card_registration_completed
+      cards = MangoPay::User.cards(new_natural_user['Id'])
+      expect(cards).to be_kind_of(Array)
+      expect(cards.count).to eq 1
+      expect(cards.first['Id']).to eq card['CardId']
+    end
+
+    it 'fetches card details' do
+        card = new_card_registration_completed
+        fetched = MangoPay::Card.fetch(card['CardId'])
+
+        expect(fetched['Id']).not_to be_nil
+        expect(fetched['UserId']).to eq(new_natural_user["Id"])
+        expect(fetched['Currency']).to eq('EUR')
+      end
+  end
+
+  describe 'FETCH BANK ACCOUNTS' do
+    it 'fetches empty list of bank accounts if no bank_accounts created' do
+      bank_accounts = MangoPay::User.bank_accounts(new_natural_user['Id'])
+      expect(bank_accounts).to be_kind_of(Array)
+      expect(bank_accounts).to be_empty
+    end
+
+    it 'fetches list with single bank_account after created' do
+      bank_account = new_bank_account
+      bank_accounts = MangoPay::User.bank_accounts(new_natural_user['Id'])
+      expect(bank_accounts).to be_kind_of(Array)
+      expect(bank_accounts.count).to eq 1
+      expect(bank_accounts.first['Id']).to eq bank_account['Id']
+    end
+  end
+
+  describe 'FETCH EMONEY' do
+    it 'fetches emoney for the user for year 2019' do
+      emoney = MangoPay::User.emoney(new_natural_user['Id'], 2019)
+      expect(emoney['UserId']).to eq new_natural_user['Id']
+      expect(emoney['CreditedEMoney']['Amount']).to eq 0
+      expect(emoney['CreditedEMoney']['Currency']).to eq 'EUR'
+      expect(emoney['DebitedEMoney']['Amount']).to eq 0
+      expect(emoney['DebitedEMoney']['Currency']).to eq 'EUR'
+    end
+
+    it 'fetches emoney for the user for date 08/2019' do
+      emoney = MangoPay::User.emoney(new_natural_user['Id'], 2019, 8)
+      expect(emoney['UserId']).to eq new_natural_user['Id']
+      expect(emoney['CreditedEMoney']['Amount']).to eq 0
+      expect(emoney['CreditedEMoney']['Currency']).to eq 'EUR'
+      expect(emoney['DebitedEMoney']['Amount']).to eq 0
+      expect(emoney['DebitedEMoney']['Currency']).to eq 'EUR'
+    end
+  end
+
+  describe 'FETCH Kyc Document' do
+    it 'fetches empty list of kyc documents if no kyc document created' do
+      documents = MangoPay::User.kyc_documents(new_natural_user['Id'])
+      expect(documents).to be_kind_of(Array)
+      expect(documents).to be_empty
+    end
+
+    it 'fetches list with single kyc document after created' do
+      document = new_document
+      documents = MangoPay::User.kyc_documents(document['UserId'])
+      expect(documents).to be_kind_of(Array)
+      expect(documents.count).to eq 1
+      expect(documents.first['Id']).to eq document['Id']
+    end
+  end
+
+  #describe 'CREATE UBO DECLARATION' do
+  #  it 'creates a UBO declaration' do
+  #    legal_user = new_legal_user
+  #    natural_user = define_new_natural_user
+  #    natural_user['Capacity'] = 'DECLARATIVE'
+  #    natural_user = MangoPay::NaturalUser.create(natural_user)
+  #    ubo_declaration = MangoPay::LegalUser.create_ubo_declaration(legal_user['Id'])
+
+  #   expect(ubo_declaration).not_to be_nil
+  #    expect(ubo_declaration['Status']).to eq 'CREATED'
+  #    expect(ubo_declaration['UserId']).to eq legal_user['Id']
+  #    expect(ubo_declaration['DeclaredUBOs'][0]['UserId']).to eq natural_user['Id']
+  #  end
+  #end
+
+  describe 'FETCH Pre-Authorizations' do
+    it "fetches list of user's pre-authorizations belonging" do
+      legal_user = new_legal_user
+      pre_authorizations = MangoPay::User.pre_authorizations(legal_user['Id'])
+      expect(pre_authorizations).to be_an(Array)
+    end
+  end
+
+=begin
+  describe 'FETCH Block Status' do
+    it "fetches user's block status" do
+      legal_user = new_legal_user
+      block_status = MangoPay::User.block_status(legal_user['Id'])
+      expect(block_status).to_not be_nil
+    end
+  end
+=end
+
+  describe 'CLOSE' do
+    it 'closes a natural user' do
+      new_user = create_new_natural_user
+      MangoPay::NaturalUser.close(new_user['Id'])
+      closed = MangoPay::User.fetch(new_user['Id'])
+      expect(closed['UserStatus']).to eq('CLOSED')
+    end
+
+    it 'closes a legal user' do
+      new_user = new_legal_user
+      MangoPay::LegalUser.close(new_user['Id'])
+      closed = MangoPay::User.fetch(new_user['Id'])
+      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