mangopay 3.0.1 → 3.0.2

data/lib/mangopay/natural_user.rb

@@ -5,7 +5,7 @@ module MangoPay
 
     def self.url(id = nil)
       if id
-        "/v2/#{MangoPay.configuration.client_id}/users/natural/#{CGI.escape(id)}"
+        "/v2/#{MangoPay.configuration.client_id}/users/natural/#{CGI.escape(id.to_s)}"
       else
         "/v2/#{MangoPay.configuration.client_id}/users/natural"
       end

data/lib/mangopay/payin.rb

@@ -8,7 +8,7 @@ module MangoPay
       class Web < Resource
         include MangoPay::HTTPCalls::Create
         private
-        def self.url(id = nil)
+        def self.url(*)
           "/v2/#{MangoPay.configuration.client_id}/payins/card/#{CGI.escape(class_name.downcase)}"
         end
       end
@@ -16,7 +16,7 @@ module MangoPay
       class Direct < Resource
         include MangoPay::HTTPCalls::Create
         private
-        def self.url(id = nil)
+        def self.url(*)
           "/v2/#{MangoPay.configuration.client_id}/payins/card/#{CGI.escape(class_name.downcase)}"
         end
       end

data/lib/mangopay/payout.rb

@@ -7,7 +7,7 @@ module MangoPay
 
       private
 
-      def self.url(id = nil)
+      def self.url(*)
         "/v2/#{MangoPay.configuration.client_id}/payouts/bankwire"
       end
     end

data/lib/mangopay/resource.rb

@@ -13,7 +13,7 @@ module MangoPay
         raise NotImplementedError.new('Resource is an abstract class. Do not use it directly.')
       end
       if id
-        "/v2/#{MangoPay.configuration.client_id}/#{CGI.escape(class_name.downcase)}s/#{CGI.escape(id)}"
+        "/v2/#{MangoPay.configuration.client_id}/#{CGI.escape(class_name.downcase)}s/#{CGI.escape(id.to_s)}"
       else
         "/v2/#{MangoPay.configuration.client_id}/#{CGI.escape(class_name.downcase)}s"
       end

data/lib/mangopay/transaction.rb

@@ -2,10 +2,25 @@ module MangoPay
   class Transaction < Resource
     include MangoPay::HTTPCalls::Fetch
 
+    # Fetches list of transactions belonging to the given +wallet_id+.
+    # 
+    # Optional +filters+ is a hash accepting following keys:
+    # - +page+, +per_page+: pagination params (see MangoPay::HTTPCalls::Fetch::ClassMethods#fetch)
+    # - +Status+: TransactionStatus {CREATED, SUCCEEDED, FAILED}
+    # - +Type+: TransactionType {PAYIN, PAYOUT, TRANSFER}
+    # - +Nature+: TransactionNature {NORMAL, REFUND, REPUDIATION}
+    # - +Direction+: TransactionDirection {DEBIT, CREDIT}
+    # - +BeforeDate+ (timestamp): filters transactions with CreationDate _before_ this date
+    # - +AfterDate+ (timestamp): filters transactions with CreationDate _after_ this date
+    #
+    def self.fetch(wallet_id, filters={})
+      MangoPay.request(:get, url(wallet_id), {}, filters)
+    end
+
     private
 
-    def self.url(id)
-      "/v2/#{MangoPay.configuration.client_id}/wallets/#{CGI.escape(id)}/transactions"
+    def self.url(wallet_id)
+      "/v2/#{MangoPay.configuration.client_id}/wallets/#{CGI.escape(wallet_id.to_s)}/transactions"
     end
   end
 end

data/lib/mangopay/version.rb

@@ -1,3 +1,3 @@
 module MangoPay
-  VERSION = '3.0.1'
+  VERSION = '3.0.2'
 end

data/spec/lib/mangopay/authorization_token_spec.rb

@@ -0,0 +1,72 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::AuthorizationToken do
+
+  _default_static_storage = MangoPay::AuthorizationToken::Manager.storage
+  _new_file_storage = MangoPay::AuthorizationToken::FileStorage.new
+
+  it 'uses StaticStorage strategy by default' do
+    storage = _default_static_storage
+    expect(storage).to be_kind_of MangoPay::AuthorizationToken::StaticStorage
+  end
+
+  it 'allows set different storage strategies' do
+
+    # set to FileStorage
+    file_storage = _new_file_storage
+    MangoPay::AuthorizationToken::Manager.storage = file_storage
+    storage = MangoPay::AuthorizationToken::Manager.storage
+    expect(storage).to be file_storage
+
+    # reset to StaticStorage
+    static_storage = _default_static_storage
+    MangoPay::AuthorizationToken::Manager.storage = static_storage
+    storage = MangoPay::AuthorizationToken::Manager.storage
+    expect(storage).to be static_storage
+  end
+
+  describe MangoPay::AuthorizationToken::StaticStorage do
+    it 'shares tokens between calls' do
+      MangoPay::AuthorizationToken::Manager.storage = _default_static_storage
+      users1 = MangoPay::User.fetch()
+      token1 = MangoPay::AuthorizationToken::Manager.get_token
+      users2 = MangoPay::User.fetch()
+      token2 = MangoPay::AuthorizationToken::Manager.get_token
+      expect(token1).to eq token2
+      expect(token1).to be token2 # moreover, it's the same instance
+    end
+  end
+
+  describe MangoPay::AuthorizationToken::FileStorage do
+    it 'shares tokens between calls' do
+      MangoPay::AuthorizationToken::Manager.storage = _new_file_storage
+
+      users1 = MangoPay::User.fetch()
+      token1 = MangoPay::AuthorizationToken::Manager.get_token
+      users2 = MangoPay::User.fetch()
+      token2 = MangoPay::AuthorizationToken::Manager.get_token
+      expect(token1).to eq token2
+      expect(token1).not_to be token2 # it's NOT the same instance
+
+      MangoPay::AuthorizationToken::Manager.storage = _default_static_storage # cleanup
+    end
+
+    it 'uses temp file with serialized token' do
+      MangoPay::AuthorizationToken::Manager.storage = _new_file_storage
+
+      file_path = _new_file_storage.file_path
+      dir_path = MangoPay.configuration.temp_dir
+      expect(file_path.start_with? dir_path).to be_true
+
+      token = MangoPay::AuthorizationToken::Manager.get_token
+      expect(File.exists? file_path).to be_true
+
+      f = File.open(file_path, File::RDONLY)
+      txt = f.read
+      f.close
+      expect(txt.include? token['access_token']).to be_true
+
+      MangoPay::AuthorizationToken::Manager.storage = _default_static_storage # cleanup
+    end
+  end
+end

data/spec/lib/mangopay/bank_account_spec.rb

@@ -1,26 +1,25 @@
-require_relative '../../spec_helper'
-
-describe MangoPay::BankAccount do
-  include_context 'users'
-  include_context 'bank_details'
-
-  describe 'CREATE' do
-    it 'creates a new bank detail' do
-      expect(new_iban_bank_detail['Id']).not_to be_nil
-    end
-  end
-
-  describe 'FETCH' do
-
-    it 'fetches all the bank details' do
-      bank_details = MangoPay::BankAccount.fetch(new_iban_bank_detail['UserId'])
-      expect(bank_details).to be_kind_of(Array)
-      expect(bank_details[0]['Id']).to eq(new_iban_bank_detail['Id'])
-    end
-
-    it 'fetches one bank detail' do
-      bank_detail = MangoPay::BankAccount.fetch(new_iban_bank_detail['UserId'], new_iban_bank_detail['Id'])
-      expect(bank_detail['Id']).to eq(new_iban_bank_detail['Id'])
-    end
-  end
-end
+require_relative '../../spec_helper'
+
+describe MangoPay::BankAccount do
+  include_context 'bank_accounts'
+
+  describe 'CREATE' do
+    it 'creates a new bank detail' do
+      expect(new_bank_account['Id']).not_to be_nil
+    end
+  end
+
+  describe 'FETCH' do
+
+    it 'fetches all the bank details' do
+      list = MangoPay::BankAccount.fetch(new_bank_account['UserId'])
+      expect(list).to be_kind_of(Array)
+      expect(list[0]['Id']).to eq(new_bank_account['Id'])
+    end
+
+    it 'fetches single bank detail' do
+      single = MangoPay::BankAccount.fetch(new_bank_account['UserId'], new_bank_account['Id'])
+      expect(single['Id']).to eq(new_bank_account['Id'])
+    end
+  end
+end

data/spec/lib/mangopay/card_registration_spec.rb

@@ -2,26 +2,28 @@ require_relative '../../spec_helper'
 
 describe MangoPay::CardRegistration do
   include_context 'users'
-  include_context 'card_registration'
+  include_context 'payins'
 
   describe 'CREATE' do
     it 'creates a new card registration' do
-      expect(new_card_registration['Id']).not_to be_nil
-      expect(new_card_registration['Id'].to_i).to be > 0
-      expect(new_card_registration['AccessKey']).not_to be_nil
-      expect(new_card_registration['PreregistrationData']).not_to be_nil
-      expect(new_card_registration['CardRegistrationURL']).not_to be_nil
-      expect(new_card_registration['CardId']).to be_nil
-      expect(new_card_registration['RegistrationData']).to be_nil
-      expect(new_card_registration['UserId']).to eq(new_natural_user["Id"])
-      expect(new_card_registration['Currency']).to eq('EUR')
-      expect(new_card_registration['Status']).to eq('CREATED')
+      created = new_card_registration
+      expect(created['Id']).not_to be_nil
+      expect(created['Id'].to_i).to be > 0
+      expect(created['AccessKey']).not_to be_nil
+      expect(created['PreregistrationData']).not_to be_nil
+      expect(created['CardRegistrationURL']).not_to be_nil
+      expect(created['RegistrationData']).to be_nil
+      expect(created['CardId']).to be_nil
+      expect(created['UserId']).to eq(new_natural_user["Id"])
+      expect(created['Currency']).to eq('EUR')
+      expect(created['Status']).to eq('CREATED')
     end
   end
 
   describe 'UPDATE' do
     it 'updates a card registration' do
-      updated = MangoPay::CardRegistration.update(new_card_registration['Id'] ,{
+      created = new_card_registration
+      updated = MangoPay::CardRegistration.update(created['Id'] ,{
         RegistrationData: 'test RegistrationData'
       })
       expect(updated['RegistrationData']).to eq('test RegistrationData')
@@ -30,10 +32,32 @@ describe MangoPay::CardRegistration do
 
   describe 'FETCH' do
     it 'fetches a card registration' do
-      fetched = MangoPay::CardRegistration.fetch(new_card_registration['Id'])
-      expect(fetched['Id']).to eq(new_card_registration['Id'])
-      expect(fetched['UserId']).to eq(new_card_registration['UserId'])
-      expect(fetched['Tag']).to eq(new_card_registration['Tag'])
+      created = new_card_registration
+      fetched = MangoPay::CardRegistration.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      expect(fetched['UserId']).to eq(created['UserId'])
+      expect(fetched['Tag']).to eq(created['Tag'])
+    end
+  end
+
+  describe 'TOKENIZATION PROCESS' do
+    it 'fills-in registration data and links it to a newly created card' do
+      completed = new_card_registration_completed
+      reg_data = completed['RegistrationData']
+      card_id = completed['CardId']
+
+      # reg data filled-in
+      expect(reg_data).not_to be_nil
+      expect(reg_data).to be_kind_of String
+      expect(reg_data).not_to be_empty
+
+      # card id filled-in...
+      expect(card_id).not_to be_nil
+      expect(card_id.to_i).to be > 0
+
+      # ...and points to existing (newly created) card
+      card = MangoPay::Card.fetch(card_id)
+      expect(card['Id']).to eq card_id
     end
   end
 

data/spec/lib/mangopay/client_spec.rb

@@ -1,5 +1,4 @@
 require_relative '../../spec_helper'
-require 'securerandom'
 
 describe MangoPay::Client do
   include_context 'clients'
@@ -12,17 +11,23 @@ describe MangoPay::Client do
     end
 
     it 'refuses the client id' do
-      expect(wrong_client['errors']).not_to be_nil
+      expect { wrong_client['errors'] }.to raise_error { |err|
+        err.should be_a MangoPay::ResponseError
+        err.type.should eq 'param_error'
+      }
     end
 
     it "ClientId_already_exist" do
-      existing_client_error = MangoPay::Client.create({
-        'ClientId' => new_client['ClientId'],
-        'Name' => 'What a nice name',
-        'Email' => 'clientemail@email.com'
-      })
-      expect(existing_client_error['Type']).to eq('ClientId_already_exist')
-      expect(existing_client_error['Message']).to eq('A partner with this ClientId already exist')
+      expect {
+        MangoPay::Client.create({
+          'ClientId' => new_client['ClientId'],
+          'Name' => 'What a nice name',
+          'Email' => 'clientemail@email.com'
+        })
+      }.to raise_error { |err|
+        err.should be_a MangoPay::ResponseError
+        err.type.should eq 'ClientId_already_exist'
+      }
     end
   end
 end

data/spec/lib/mangopay/configuration_spec.rb

@@ -0,0 +1,20 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::Configuration do
+
+  it 'fails when calling with wrong client credentials' do
+    expect {
+      c = MangoPay.configuration
+      c.client_id = 'test_asd'
+      c.client_passphrase = '00000'
+      MangoPay::User.fetch()
+    }.to raise_error(MangoPay::ResponseError)
+  end
+
+  it 'goes ok when calling with correct client credentials' do
+    reset_mangopay_configuration
+    users = MangoPay::User.fetch()
+    expect(users).to be_kind_of(Array)
+  end
+
+end

data/spec/lib/mangopay/fetch_filters_spec.rb

@@ -0,0 +1,65 @@
+require_relative '../../spec_helper'
+
+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/lib/mangopay/payin_card_direct_spec.rb

@@ -0,0 +1,70 @@
+require_relative '../../spec_helper'
+
+describe MangoPay::PayIn::Card::Direct, type: :feature do
+  include_context 'wallets'
+  include_context 'payins'
+  
+  def check_type_and_status(payin)
+    expect(payin['Type']).to eq('PAYIN')
+    expect(payin['Nature']).to eq('REGULAR')
+    expect(payin['PaymentType']).to eq('CARD')
+    expect(payin['ExecutionType']).to eq('DIRECT')
+
+    # SUCCEEDED
+    expect(payin['Status']).to eq('SUCCEEDED')
+    expect(payin['ResultCode']).to eq('000000')
+    expect(payin['ResultMessage']).to eq('Success')
+    expect(payin['ExecutionDate']).to be > 0
+  end
+
+  describe 'CREATE' do
+    it 'creates a card direct payin' do
+      created = new_payin_card_direct
+      expect(created['Id']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payin' do
+      created = new_payin_card_direct
+      fetched = MangoPay::PayIn.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      expect(fetched['CreationDate']).to eq(created['CreationDate'])
+      expect(fetched['CreditedFunds']).to eq(created['CreditedFunds'])
+      expect(fetched['CreditedWalletId']).to eq(created['CreditedWalletId'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
+    end
+  end
+
+  describe 'REFUND' do
+    it 'refunds a payin' do
+      payin = new_payin_card_direct
+      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')
+      expect(refund['Nature']).to eq('REFUND')
+      expect(refund['InitialTransactionType']).to eq('PAYIN')
+      expect(refund['InitialTransactionId']).to eq(payin['Id'])
+      expect(refund['DebitedWalletId']).to eq(payin['CreditedWalletId'])
+    end
+  end
+
+  describe 'CASH FLOW' do
+    it 'changes balances correctly' do
+      wlt = new_wallet
+      wallets_check_amounts(wlt, 0)
+
+      # payin: feed wlt1 with money
+      payin = create_new_payin_card_direct(wlt, 1000)
+      wallets_reload_and_check_amounts(wlt, 1000)
+
+      # refund the payin
+      refund = MangoPay::PayIn.refund(payin['Id'], {AuthorId: payin['AuthorId']})
+      wallets_reload_and_check_amounts(wlt, 0)
+    end
+  end
+
+end