mangopay 3.0.25.pre.alpha.pre.20 → 3.0.25

data/spec/mangopay/temp_paymentcard_spec.rb

@@ -1,31 +1,31 @@
-describe MangoPay::Temp::PaymentCard do
-  include_context 'users'
-
-  def new_temp_paymentcard
-    MangoPay::Temp::PaymentCard.create({
-      Tag: 'Test temp payment card',
-      UserId: new_natural_user['Id'],
-      Culture: 'FR',
-      ReturnURL: 'https://mysite.com/return',
-      TemplateURL: 'https://mysite.com/template'
-    })
-  end
-
-  describe 'CREATE' do
-    it 'creates a temp payment card' do
-      created = new_temp_paymentcard
-      expect(created['Id']).to_not be_nil
-      expect(created['UserId']).to eq(new_natural_user['Id'])
-    end
-  end
-
-  describe 'FETCH' do
-    it 'fetches a temp payment card' do
-      created = new_temp_paymentcard
-      fetched = MangoPay::Temp::PaymentCard.fetch(created['Id'])
-      expect(fetched['Id']).to eq(created['Id'])
-      expect(fetched['UserId']).to eq(created['UserId'])
-    end
-  end
-
-end
+describe MangoPay::Temp::PaymentCard do
+  include_context 'users'
+
+  def new_temp_paymentcard
+    MangoPay::Temp::PaymentCard.create({
+      Tag: 'Test temp payment card',
+      UserId: new_natural_user['Id'],
+      Culture: 'FR',
+      ReturnURL: 'https://mysite.com/return',
+      TemplateURL: 'https://mysite.com/template'
+    })
+  end
+
+  describe 'CREATE' do
+    it 'creates a temp payment card' do
+      created = new_temp_paymentcard
+      expect(created['Id']).to_not be_nil
+      expect(created['UserId']).to eq(new_natural_user['Id'])
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a temp payment card' do
+      created = new_temp_paymentcard
+      fetched = MangoPay::Temp::PaymentCard.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      expect(fetched['UserId']).to eq(created['UserId'])
+    end
+  end
+
+end

data/spec/mangopay/transaction_spec.rb

@@ -1,54 +1,54 @@
-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)
-      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']
-
-      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
+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)
+      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']
+
+      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

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

data/spec/mangopay/user_spec.rb

@@ -1,137 +1,137 @@
-describe MangoPay::User do
-  include_context 'users'
-  include_context 'payins'
-  include_context 'payouts'
-  include_context 'wallets'
-
-  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
-  end
-
-  describe 'UPDATE' do
-    it 'updates a natural user' do
-      updated_user = MangoPay::NaturalUser.update(new_natural_user['Id'] ,{
-        FirstName: 'Jack'
-      })
-      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'
-      })
-      expect(updated_user['LegalRepresentativeFirstName']).to eq('Jack')
-    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 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)
-      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
-  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
-  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
-  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
-end
+describe MangoPay::User do
+  include_context 'users'
+  include_context 'payins'
+  include_context 'payouts'
+  include_context 'wallets'
+
+  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
+  end
+
+  describe 'UPDATE' do
+    it 'updates a natural user' do
+      updated_user = MangoPay::NaturalUser.update(new_natural_user['Id'] ,{
+        FirstName: 'Jack'
+      })
+      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'
+      })
+      expect(updated_user['LegalRepresentativeFirstName']).to eq('Jack')
+    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 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)
+      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
+  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
+  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
+  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
+end