mangopay 3.0.25 → 3.0.26

data/spec/mangopay/event_spec.rb

@@ -1,31 +1,31 @@
-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
-      events = MangoPay::Event.fetch({'AfterDate' => payin['CreationDate'], 'BeforeDate' => payin['CreationDate']})
-      expect(events).to be_kind_of(Array)
-      expect(events.count).to be >= 1
-      expect(events.count { |e| e['ResourceId'] == payin['Id'] }).to be >= 1
-    end
-  end
-end
+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
+      events = MangoPay::Event.fetch({'AfterDate' => payin['CreationDate'], 'BeforeDate' => payin['CreationDate']})
+      expect(events).to be_kind_of(Array)
+      expect(events.count).to be >= 1
+      expect(events.count { |e| e['ResourceId'] == payin['Id'] }).to be >= 1
+    end
+  end
+end

data/spec/mangopay/fetch_filters_spec.rb

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

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

@@ -1,41 +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
+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/kyc_document_spec.rb

@@ -1,103 +1,103 @@
-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
-    end
-  end
-
-  describe 'UPDATE' do
-    it 'updates a document' do
-      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()
-      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'})
-      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 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 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
-  end
-end
+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
+    end
+  end
+
+  describe 'UPDATE' do
+    it 'updates a document' do
+      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()
+      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'})
+      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 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 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
+  end
+end