mangopay4-ruby-sdk 3.44.0

data/spec/mangopay/dispute_spec.rb

@@ -0,0 +1,294 @@
+describe MangoPay::Dispute do
+
+=begin
+comment out all Dispute related unit tests please
+these require manual actions on our side
+and it's infact not suitable like that
+
+  # IMPORTANT NOTE!
+  # 
+  # Due to the fact the disputes CANNOT be created on user's side,
+  # a special approach in testing is needed. 
+  # In order to get the tests below pass, a bunch of disputes have
+  # to be prepared on the API server side - if they're not, you can
+  # just skip these tests, as they won't pass.
+  before(:each) do
+    @disputes = MangoPay::Dispute.fetch({'page' => 1, 'per_page' => 100})
+  end
+
+  describe 'FETCH' do
+    it 'fetches disputes' do
+      expect(@disputes).to be_kind_of(Array)
+      expect(@disputes).not_to be_empty
+    end
+    it 'fetches a dispute' do
+      id = @disputes.first['Id']
+      dispute = MangoPay::Dispute.fetch(id)
+      expect(dispute['Id']).to eq(id)
+    end
+  end
+
+  describe 'TRANSACTIONS' do
+    it 'fetches transactions for dispute' do
+      dispute = @disputes.find { |d| d['DisputeType'] == 'NOT_CONTESTABLE' }
+      id = dispute['Id']
+      transactions = MangoPay::Dispute.transactions(id, {'per_page' => 1})
+      expect(transactions).to be_kind_of(Array)
+      expect(transactions).not_to be_empty
+    end
+  end
+
+  describe 'FETCH FOR USER AND WALLET' do
+    it 'fetches disputes for user' do
+      dispute = @disputes.find { |d| d['DisputeType'] == 'NOT_CONTESTABLE' }
+      id = dispute['Id']
+      transactions = MangoPay::Dispute.transactions(id, {'per_page' => 1})
+      user_id = transactions[0]['AuthorId']
+      disputes = MangoPay::Dispute.fetch_for_user(user_id, {'per_page' => 1})
+      expect(disputes).to be_kind_of(Array)
+      expect(disputes).not_to be_empty
+    end
+    it 'fetches disputes for wallet' do
+      payin = MangoPay::PayIn.fetch("133379281")
+      wallet_id = payin['CreditedWalletId']
+      disputes = MangoPay::Dispute.fetch_for_wallet(wallet_id, {'per_page' => 1})
+      expect(disputes).to be_kind_of(Array)
+      expect(disputes).not_to be_empty
+    end
+    it 'fetches disputes for payin' do
+      disputes = MangoPay::Dispute.fetch_for_pay_in("133379281", {'per_page' => 1})
+      expect(disputes).to be_kind_of(Array)
+      expect(disputes).not_to be_empty
+    end
+  end
+
+  describe 'UPDATE' do
+    it 'updates a dispute' do
+      dispute = @disputes.first
+      id = dispute['Id']
+      new_tag = dispute['Tag'] + '.com'
+      changed_dispute = MangoPay::Dispute.update(id, {Tag: new_tag})
+      expect(changed_dispute['Tag']).to eq(new_tag)
+    end
+  end
+
+  describe 'FETCH REPUDIATION' do
+    it 'fetches a repudiation' do
+      dispute = @disputes.find {|disp| disp['InitialTransactionId'] != nil && disp['DisputeType'] == 'NOT_CONTESTABLE'}
+      expect(dispute).not_to be_nil, "Cannot test closing dispute because there's no not contestable disputes with transaction ID in the disputes list."
+      transactions = MangoPay::Dispute.transactions(dispute['Id'], {'per_page' => 1})
+      repudiation_id = transactions[0]['Id']
+      repudiation = MangoPay::Dispute.fetch_repudiation(repudiation_id)
+      expect(repudiation['Id']).to eq(repudiation_id)
+      expect(repudiation['Nature']).to eq('REPUDIATION')
+    end
+  end
+
+  describe 'CREATE AND FETCH SETTLEMENT TRANSFER' do
+    it 'creates and fetches settlement transfer' do
+      dispute = @disputes.find {|disp| disp['Status'] == 'CLOSED' && disp['DisputeType'] == 'NOT_CONTESTABLE'}
+      expect(dispute).not_to be_nil, "Cannot test creating settlement transfer because there's no closed, not contestable disputes in the disputes list."
+      transactions = MangoPay::Dispute.transactions(dispute['Id'], {'per_page' => 1})
+      repudiation_id = transactions[0]['Id']
+      repudiation = MangoPay::Dispute.fetch_repudiation(repudiation_id)
+      params = {
+        AuthorId: repudiation['AuthorId'],
+        DebitedFunds: {Currency: 'EUR', Amount: 1},
+        Fees: {Currency: 'EUR', Amount: 0},
+        Tag: 'Custom tag data'
+      }
+
+      transfer = MangoPay::Dispute.create_settlement_transfer(repudiation_id, params)
+      expect(transfer['Type']).to eq('TRANSFER')
+      expect(transfer['Nature']).to eq('SETTLEMENT')
+
+      fetched_transfer = MangoPay::Dispute.fetch_settlement_transfer(transfer['Id'])
+      expect(fetched_transfer['Id']).to eq(transfer['Id'])
+      expect(fetched_transfer['CreationDate']).to eq(transfer['CreationDate'])
+    end
+  end
+
+  # NOTE: This test has not been run. Please check it if you have the chance.
+  describe 'GET DISPUTES PENDING SETTLEMENT' do
+    it 'retrieves disputes awaiting settlement actions' do
+      disputes_pending = MangoPay::Dispute.fetch_pending_settlement
+
+      expect(disputes_pending).to be_kind_of Array
+      disputes_pending.each do |dispute|
+        expect(dispute['Id']).not_to be_nil
+        # TODO: Maybe check for corresponding status
+      end
+    end
+  end
+
+  describe 'DISPUTE DOCUMENTS API' do
+
+    def find_dispute
+      dispute = @disputes.find {|disp| ['PENDING_CLIENT_ACTION', 'REOPENED_PENDING_CLIENT_ACTION'].include?(disp['Status'])}
+      expect(dispute).not_to be_nil, "Cannot test dispute document API because there's no dispute with expected status in the disputes list."
+      dispute
+    end
+
+    def create_doc(dispute = nil)
+      no_dispute_passed = dispute.nil?
+      dispute = find_dispute if no_dispute_passed
+      params = { Type: 'DELIVERY_PROOF', Tag: 'Custom tag data' }
+      doc = MangoPay::Dispute.create_document(dispute['Id'], params)
+      doc['dispute'] = dispute if no_dispute_passed # add it for testing purposes
+      doc
+    end
+
+    it 'creates dispute document' do
+      doc = create_doc
+      expect(doc['Type']).to eq('DELIVERY_PROOF')
+      expect(doc['Tag']).to eq('Custom tag data')
+      expect(doc['Status']).to eq('CREATED')
+    end
+
+    it 'fetches dispute document' do
+      created_doc = create_doc
+      fetched_doc = MangoPay::Dispute.fetch_document(created_doc['Id'])
+      fields = ['Id', 'Type', 'Tag', 'Status', 'CreationDate', 'RefusedReasonType', 'RefusedReasonMessage']
+      fields.each do |field|
+        expect(fetched_doc[field]).to eq(created_doc[field])
+      end
+    end
+
+    it 'updates dispute document' do
+      created_doc = create_doc
+      
+      fnm = __FILE__.sub('.rb', '.png')
+      ret = MangoPay::Dispute.create_document_page(created_doc['dispute']['Id'], created_doc['Id'], nil, fnm)
+      
+      changed_doc = MangoPay::Dispute.update_document(created_doc['dispute']['Id'], created_doc['Id'], {
+        Status: 'VALIDATION_ASKED'
+      })
+      expect(changed_doc['Id']).to eq(created_doc['Id'])
+      expect(changed_doc['Status']).to eq('VALIDATION_ASKED')
+    end
+
+    it 'fetches a list of documents' do
+      disp = @disputes.find {|disp| disp['Status'] == 'SUBMITTED'}
+      disp = test_contest_dispute if disp == nil
+      expect(disp).not_to be_nil, "Cannot test fetching dispute documents because there's no dispute with expected status in the disputes list."
+
+      doc1 = create_doc(disp)
+      doc2 = create_doc(disp) # for the same dispute
+
+      filters = {'per_page' => 2, 'sort' => 'CreationDate:desc'}
+
+      # fetch last 2 docs for the dispute
+      docs = MangoPay::Dispute.fetch_documents(disp['Id'], filters)
+      expect(docs).to be_kind_of(Array)
+      expect(docs.count).to eq 2 # exactly 2 as pagiantion requested
+      # all 2 are at top as lastly created
+      # but may share the same CreationDate
+      # so the order between them is undetermined
+      expect(docs).to include(doc1, doc2)
+
+      # fetch all docs ever
+      docs = MangoPay::Dispute.fetch_documents()
+      expect(docs).to be_kind_of(Array)
+      expect(docs.count).to be >= 2
+
+      # fetch last 2 docs ever (sorting by date descending)
+      docs = MangoPay::Dispute.fetch_documents(nil, filters)
+      expect(docs).to be_kind_of(Array)
+      expect(docs.count).to eq 2 # exactly 2 as pagiantion requested
+      expect(docs).to include(doc1, doc2)
+    end
+
+    def create_doc_page(file)
+      disp = find_dispute
+      doc = create_doc(disp)
+      MangoPay::Dispute.create_document_page(disp['Id'], doc['Id'], file)
+    end
+
+    it 'create_document_page accepts Base64 encoded file content' do
+      fnm = __FILE__.sub('.rb', '.png')
+      bts = File.open(fnm, 'rb') { |f| f.read }
+      b64 = Base64.encode64(bts)
+      ret = create_doc_page(b64)
+      expect(ret).to be_nil
+    end
+
+    it 'create_document_page accepts file path' do
+      fnm = __FILE__.sub('.rb', '.png')
+      disp = find_dispute
+      doc = create_doc(disp)
+      ret = MangoPay::Dispute.create_document_page(disp['Id'], doc['Id'], nil, fnm)
+      expect(ret).to be_nil
+    end
+
+    it 'create_document_page fails when input string is not base64-encoded' do
+      file = 'any file content...'
+      expect { create_doc_page(file) }.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
+
+  # TODO: Run this test when possible
+  it 'create_document_consult fetches a list of document page consults' do
+    fnm = __FILE__.sub('.rb', '.png')
+    disp = find_dispute
+    doc = create_doc(disp)
+    MangoPay::Dispute.create_document_page(disp['Id'], doc['Id'], nil, fnm)
+    consults = MangoPay::Dispute.create_document_consult(doc['Id'])
+
+    expect(consults).not_to be_nil
+    expect(consults).to be_kind_of(Array)
+  end
+
+  def test_contest_dispute
+      dispute = @disputes.find do |disp|
+        ['PENDING_CLIENT_ACTION', 'REOPENED_PENDING_CLIENT_ACTION'].include?(disp['Status']) &&
+        ['CONTESTABLE', 'RETRIEVAL'].include?(disp['DisputeType'])
+      end
+      expect(dispute).not_to be_nil, "Cannot test contesting dispute because there's no available disputes with expected status and type in the disputes list."
+      id = dispute['Id']
+      contested_funds = dispute['Status'] == 'PENDING_CLIENT_ACTION' ? { Amount: 10, Currency: 'EUR' } : nil;
+      changed_dispute = MangoPay::Dispute.contest(id, contested_funds)
+      expect(changed_dispute['Id']).to eq(id)
+      expect(changed_dispute['Status']).to eq('SUBMITTED')
+      changed_dispute
+  end
+
+  describe 'CONTEST' do
+    it 'contests a dispute' do
+      test_contest_dispute
+    end
+  end
+
+  describe 'RESUBMIT' do
+    it 'resubmits a dispute' do
+      dispute = @disputes.find do |disp|
+        ['REOPENED_PENDING_CLIENT_ACTION'].include?(disp['Status'])
+      end
+      expect(dispute).not_to be_nil, "Cannot test resubmiting dispute because there's no available disputes with expected status in the disputes list."
+      id = dispute['Id']
+      changed_dispute = MangoPay::Dispute.resubmit(id)
+      expect(changed_dispute['Id']).to eq(id)
+      expect(changed_dispute['Status']).to eq('SUBMITTED')
+    end
+  end
+
+  describe 'CLOSE' do
+    it 'closes a dispute' do
+      dispute = @disputes.find do |disp|
+        ['PENDING_CLIENT_ACTION', 'REOPENED_PENDING_CLIENT_ACTION'].include?(disp['Status']) &&
+        ['CONTESTABLE', 'RETRIEVAL'].include?(disp['DisputeType'])
+      end
+      expect(dispute).not_to be_nil, "Cannot test closing dispute because there's no available disputes with expected status in the disputes list."
+      id = dispute['Id']
+      changed_dispute = MangoPay::Dispute.close(id)
+      expect(changed_dispute['Id']).to eq(id)
+      expect(changed_dispute['Status']).to eq('CLOSED')
+    end
+  end
+
+=end
+
+end

data/spec/mangopay/event_spec.rb

@@ -0,0 +1,33 @@
+describe MangoPay::Event do
+
+  include_context 'payins'
+  include_context 'payouts'
+
+  describe 'FETCH' do
+
+    it 'accepts filtering params' do
+
+      # let's have at least 2 events
+      payin = new_payin_card_direct
+      create_new_payout_bankwire(payin)
+
+      # get all #
+      events = MangoPay::Event.fetch
+      expect(events).to be_kind_of(Array)
+      expect(events.count).to be >= 2
+
+      # only one per page #
+      events = MangoPay::Event.fetch({'per_page' => 1})
+      expect(events).to be_kind_of(Array)
+      expect(events.count).to eq 1
+
+      # filter by date
+      eventDate = events[0]["Date"]
+      resourceId=events[0]["ResourceId"]
+      events = MangoPay::Event.fetch({'AfterDate' => eventDate - 1, 'BeforeDate' => eventDate + 1})
+      expect(events).to be_kind_of(Array)
+      expect(events.count).to be >= 1
+      expect(events.count {|e| e['ResourceId'] == resourceId}).to be >= 1
+    end
+  end
+end

data/spec/mangopay/fetch_filters_spec.rb

@@ -0,0 +1,63 @@
+describe 'FETCH WITH FILTERS' do
+  include_context 'users'
+  include_context 'bank_accounts'
+
+  describe 'FETCH USERS' do
+
+    it 'returns single hash when called with id' do
+      id = new_natural_user['Id']
+      res = MangoPay::User.fetch(id)
+      expect(res).to be_kind_of Hash
+      expect(res['Id']).to eq id
+    end
+
+    it 'returns list of hashes with default pagination when called with no param' do
+      res = MangoPay::User.fetch()
+      expect(res).to be_kind_of Array
+      expect(res.count).to eq 10
+    end
+
+    it 'returns list of hashes with default pagination when called with empty filters' do
+      res = MangoPay::User.fetch(filters = {})
+      expect(res).to be_kind_of Array
+      expect(res.count).to eq 10
+      expect(filters['total_items']).to be > 0
+      expect(filters['total_pages']).to be > 0
+    end
+
+    it 'returns list of hashes with correct pagination when called with pagination filters' do
+      res = MangoPay::User.fetch(filters = {page:2, per_page:3})
+      expect(res).to be_kind_of Array
+      expect(res.count).to eq 3 # 3 items per page as requested
+      expect(filters['total_items']).to be > 0
+      expect(filters['total_pages']).to be > 0
+    end
+  end
+
+  describe 'FETCH BANK ACCOUNTS OF USER' do
+
+    it 'returns single hash when called with user id and account id' do
+      bank_account = new_bank_account
+      res = MangoPay::BankAccount.fetch(bank_account['UserId'], bank_account['Id'])
+      expect(res).to be_kind_of Hash
+      expect(res['Id']).to eq bank_account['Id']
+    end
+
+    it 'returns list of hashes with default pagination when called with user id only' do
+      bank_account = new_bank_account
+      res = MangoPay::BankAccount.fetch(bank_account['UserId'])
+      expect(res).to be_kind_of Array
+      expect(res.count).to eq 1 # not enough items to fill-in whole page
+    end
+
+    it 'returns list of hashes with default pagination when called with empty filters' do
+      bank_account = new_bank_account
+      res = MangoPay::BankAccount.fetch(bank_account['UserId'], filters = {})
+      expect(res).to be_kind_of Array
+      expect(res.count).to eq 1 # not enough items to fill-in whole page
+      expect(filters['total_items']).to eq 1
+      expect(filters['total_pages']).to eq 1
+    end
+  end
+
+end

data/spec/mangopay/hook_spec.rb

@@ -0,0 +1,37 @@
+describe MangoPay::Hook do
+  include_context 'hooks'
+
+  describe 'CREATE' do
+    it 'creates a hook' do
+      expect(new_hook['Id']).to_not be_nil
+    end
+  end
+
+  describe 'UPDATE' do
+    it 'updates a hook' do
+      new_url = new_hook['Url'] + '.com'
+      updated_hook = MangoPay::Hook.update(new_hook['Id'], {
+        Url: new_url,
+        Tag: 'Updated Tag'
+      })
+    expect(updated_hook['Url']).to eq(new_url)
+      expect(updated_hook['Tag']).to eq('Updated Tag')
+    end
+  end
+
+  describe 'FETCH' do
+
+    it 'fetches a hook' do
+      hook = MangoPay::Hook.fetch(new_hook['Id'])
+      expect(hook['Id']).to eq(new_hook['Id'])
+    end
+
+    it 'fetches all the hooks' do
+      hooks = MangoPay::Hook.fetch()
+      expect(hooks).to be_kind_of(Array)
+      expect(hooks).not_to be_empty
+    end
+
+  end
+
+end

data/spec/mangopay/idempotency_spec.rb

@@ -0,0 +1,41 @@
+describe MangoPay do
+
+  # see https://docs.mangopay.com/api-references/idempotency-support/
+
+  include_context 'users'
+  require 'securerandom'
+
+  describe 'post requests' do
+
+    it 'if called with no idempotency key, act independently' do
+      u = define_new_natural_user
+      u1 = MangoPay::NaturalUser.create(u)
+      u2 = MangoPay::NaturalUser.create(u)
+      expect(u2['Id']).to be > u1['Id']
+    end
+
+    it 'if called with same idempotency key, the 2nd call is blocked' do
+      idempotency_key = SecureRandom.uuid
+      u = define_new_natural_user
+      u1 = MangoPay::NaturalUser.create(u, nil, idempotency_key)
+      expect {
+        u2 = MangoPay::NaturalUser.create(u, nil, idempotency_key)
+      }.to raise_error(MangoPay::ResponseError)
+    end
+
+    it 'if called with different idempotency key, act independently and responses may be retreived later' do
+      idempotency_key1 = SecureRandom.uuid
+      idempotency_key2 = SecureRandom.uuid
+      u = define_new_natural_user
+      u1 = MangoPay::NaturalUser.create(u, nil, idempotency_key1)
+      u2 = MangoPay::NaturalUser.create(u, nil, idempotency_key2)
+      expect(u2['Id']).to be > u1['Id']
+
+      resp1 = MangoPay.fetch_response(idempotency_key1)
+      resp2 = MangoPay.fetch_response(idempotency_key2)
+      expect(resp1['Resource']['Id']).to eq u1['Id']
+      expect(resp2['Resource']['Id']).to eq u2['Id']
+    end
+
+  end
+end

data/spec/mangopay/identity_verification_spec.rb

@@ -0,0 +1,47 @@
+describe MangoPay::IdentityVerification do
+  include_context 'users'
+
+  describe 'CREATE' do
+    it 'creates a new identity verification' do
+      created = create_new_identity_verification
+      expect(created).not_to be_nil
+      expect(created['HostedUrl']).not_to be_nil
+      expect(created['ReturnUrl']).not_to be_nil
+      expect(created['Status']).to eq('PENDING')
+    end
+  end
+
+  describe 'GET' do
+    it 'fetches existing identity verification' do
+      created = create_new_identity_verification
+      fetched = MangoPay::IdentityVerification.get(created['Id'])
+
+      expect(fetched).not_to be_nil
+      expect(created['HostedUrl']).to eq(fetched['HostedUrl'])
+      expect(created['ReturnUrl']).to eq(fetched['ReturnUrl'])
+      expect(created['Status']).to eq(fetched['Status'])
+    end
+
+    it 'fetches all identity verifications for a user' do
+      create_new_identity_verification
+      user = new_natural_user
+      fetched = MangoPay::IdentityVerification.get_all(user['Id'])
+
+      expect(fetched).not_to be_nil
+      expect(fetched).to be_kind_of(Array)
+      expect(fetched).not_to be_empty
+    end
+  end
+
+  def create_new_identity_verification
+    user = new_natural_user
+    return MangoPay::IdentityVerification.create(
+      {
+        ReturnUrl: 'http://example.com',
+        Tag: 'created by the Ruby SDK'
+      },
+      user['Id']
+    )
+  end
+
+end

data/spec/mangopay/kyc_document_spec.rb

@@ -0,0 +1,118 @@
+describe MangoPay::KycDocument do
+  include_context 'kyc_documents'
+
+  describe 'CREATE' do
+    it 'creates a document' do
+      expect(new_document['Id']).to_not be_nil
+      expect(new_document['Type']).to eq('IDENTITY_PROOF')
+      expect(new_document['Status']).to eq('CREATED')
+      expect(new_document['RefusedReasonType']).to be_nil
+      expect(new_document['RefusedReasonMessage']).to be_nil
+      expect(new_document['Flags']).to match_array([])
+    end
+  end
+
+  describe 'UPDATE' do
+    it 'updates a document' do
+      fnm = __FILE__.sub('.rb', '.png')
+      ret = MangoPay::KycDocument.create_page(new_natural_user['Id'], new_document['Id'], nil, fnm)
+      
+      updated_document = MangoPay::KycDocument.update(new_natural_user['Id'], new_document['Id'], {
+        Status: 'VALIDATION_ASKED'
+      })
+      expect(updated_document['Id']).to eq(new_document['Id'])
+      expect(updated_document['Status']).to eq('VALIDATION_ASKED')
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a document' do
+      document = MangoPay::KycDocument.fetch(new_natural_user['Id'], new_document['Id'])
+      expect(document['Id']).to eq(new_document['Id'])
+    end
+
+    it 'fetches a document just by id' do
+      document = MangoPay::KycDocument.fetch(nil, new_document['Id'])
+      expect(document['Id']).to eq(new_document['Id'])
+    end
+  end
+
+  describe 'FETCH ALL' do
+    it 'fetches a list of documents' do
+      usr1 = create_new_natural_user()
+      usr2 = create_new_natural_user()
+      doc1 = create_new_document(usr1)
+      doc2 = create_new_document(usr1)
+      doc3 = create_new_document(usr2)
+
+      # fetch all docs for user 1
+      docs = MangoPay::KycDocument.fetch_all(usr1['Id'])
+      expect(docs).to be_kind_of(Array)
+      expect(docs.count).to eq 2
+      expect(docs[0]['Id']).to eq doc1['Id']
+      expect(docs[1]['Id']).to eq doc2['Id']
+
+      # fetch all docs for user 2
+      docs = MangoPay::KycDocument.fetch_all(usr2['Id'])
+      expect(docs).to be_kind_of(Array)
+      expect(docs.count).to eq 1
+      expect(docs[0]['Id']).to eq doc3['Id']
+
+      # fetch all docs ever
+      docs = MangoPay::KycDocument.fetch_all(nil, {'afterdate' => doc1['CreationDate'] - 500, 'beforedate' => doc1['CreationDate'] + 500})
+      expect(docs).to be_kind_of(Array)
+      expect(docs.count).to be >= 3 # at least last 3 docs, but probably many more
+
+      # fetch last 3 docs (sorting by date descending)
+      docs = MangoPay::KycDocument.fetch_all(nil, filter = {'page' => 1, 'per_page' => 3, 'sort' => 'CreationDate:desc', 'afterdate' => doc1['CreationDate'] - 500, 'beforedate' => doc1['CreationDate'] + 500})
+      expect(docs).to be_kind_of(Array)
+      expect(docs.count).to eq 3
+      # all 3 are at top as lastly created
+      # but may share the same CreationDate
+      # so the order between them is undetermined
+      expect(docs).to include(doc1, doc2, doc3)
+
+    end
+  end
+
+  describe 'CREATE PAGE' do
+
+    def create_page(file)
+      MangoPay::KycDocument.create_page(new_natural_user['Id'], new_document['Id'], file)
+    end
+
+    it 'accepts Base64 encoded file content' do
+      fnm = __FILE__.sub('.rb', '.png')
+      bts = File.open(fnm, 'rb') { |f| f.read }
+      b64 = Base64.encode64(bts)
+      ret = create_page(b64)
+      expect(ret).to_not be_nil
+    end
+
+    it 'accepts file path' do
+      fnm = __FILE__.sub('.rb', '.png')
+      ret = MangoPay::KycDocument.create_page(new_natural_user['Id'], new_document['Id'], nil, fnm)
+      expect(ret).to_not be_nil
+    end
+
+    it 'fails when input string is not base64-encoded' do
+      file = 'any file content...'
+      expect { create_page(file) }.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
+
+    describe 'CREATE CONSULT' do
+      it 'creates document pages consult' do
+        fnm = __FILE__.sub('.rb', '.png')
+        MangoPay::KycDocument.create_page(new_natural_user['Id'], new_document['Id'], nil, fnm)
+
+        consult = MangoPay::KycDocument.create_documents_consult(new_document['Id'])
+        expect(consult).not_to be_nil
+        expect(consult).to be_kind_of(Array)
+      end
+    end
+  end
+end

data/spec/mangopay/log_requests_filter_spec.rb

@@ -0,0 +1,26 @@
+describe MangoPay do
+  include_context 'users'
+  include_context 'payins'
+  require 'json'
+
+  describe 'requests log file' do
+
+    let(:log_file) do
+      File.join(MangoPay.configuration.temp_dir, 'mangopay.log.tmp')
+    end
+
+    it 'filters confidential parameters' do
+      FileUtils.rm_f(log_file)
+      MangoPay.configuration.log_file = log_file
+      created = new_card_registration
+      lines = File.open(log_file).select { |l| l.include?('AccessKey') }
+      lines.each do |line|
+        result = JSON.load(/({.+})\s+$/.match(line)[0])
+        expect(result['AccessKey']).to eq('[FILTERED]')
+        expect(result['Id']).not_to eq('[FILTERED]')
+      end
+      FileUtils.rm_f(log_file)
+    end
+
+  end
+end