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

data/mangopay.gemspec

@@ -1,31 +1,30 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
-
-require 'mangopay/version'
-
-Gem::Specification.new do |s|
-  s.name        = 'mangopay'
-  s.version     = MangoPay::VERSION
-  s.version = "#{s.version}-alpha-#{ENV['TRAVIS_BUILD_NUMBER']}" if ENV['TRAVIS']
-  s.summary     = "Ruby bindings for the version 2 of the MANGOPAY API"
-  s.description = <<-EOF
-  The mangopay Gem makes interacting with MANGOPAY Services much easier.
-  For any questions regarding the use of MANGOPAY's Services feel free to contact us at http://www.mangopay.com/get-started-2/
-  You can find more documentation about MANGOPAY Services at http://docs.mangopay.com/
-  EOF
-  s.authors     = ['Geoffroy Lorieux', 'Sergiusz Woznicki']
-  s.email       = 'support@mangopay.com'
-  s.homepage    = 'http://docs.mangopay.com/'
-  s.license     = 'MIT'
-
-  s.required_ruby_version = '>= 1.9.2'
-
-  s.add_dependency('multi_json', '>= 1.7.7')
-
-  s.add_development_dependency('rake', '>= 10.1.0')
-  s.add_development_dependency('rspec', '>= 3.0.0')
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- spec/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ['lib']
-end
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'mangopay/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'mangopay'
+  s.version     = MangoPay::VERSION
+  s.summary     = "Ruby bindings for the version 2 of the MANGOPAY API"
+  s.description = <<-EOF
+  The mangopay Gem makes interacting with MANGOPAY Services much easier.
+  For any questions regarding the use of MANGOPAY's Services feel free to contact us at http://www.mangopay.com/get-started-2/
+  You can find more documentation about MANGOPAY Services at http://docs.mangopay.com/
+  EOF
+  s.authors     = ['Geoffroy Lorieux', 'Sergiusz Woznicki']
+  s.email       = 'support@mangopay.com'
+  s.homepage    = 'http://docs.mangopay.com/'
+  s.license     = 'MIT'
+
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.add_dependency('multi_json', '>= 1.7.7')
+
+  s.add_development_dependency('rake', '>= 10.1.0')
+  s.add_development_dependency('rspec', '>= 3.0.0')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/spec/mangopay/authorization_token_spec.rb

@@ -1,70 +1,70 @@
-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
+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/mangopay/bank_account_spec.rb

@@ -1,97 +1,97 @@
-describe MangoPay::BankAccount do
-  include_context 'bank_accounts'
-
-  def create(params)
-    user = new_natural_user
-    params_fixed = { OwnerName: 'John', OwnerAddress: user['Address'] }.merge(params)
-    MangoPay::BankAccount.create(user['Id'], params_fixed)
-  end
-
-  describe 'CREATE' do
-
-    it 'creates a new IBAN bank detail' do
-      expect(new_bank_account['Id']).not_to be_nil
-    end
-
-    it 'creates a new GB bank detail' do
-      created = create({
-        Type: 'GB',
-        AccountNumber: '63956474',
-        SortCode: '200000',
-      })
-      expect(created['Id']).not_to be_nil
-      expect(created['Type']).to eq('GB')
-      expect(created['AccountNumber']).to eq('63956474')
-      expect(created['SortCode']).to eq('200000')
-    end
-
-    it 'creates a new US bank detail' do
-      created = create({
-        Type: 'US',
-        AccountNumber: '234234234234',
-        ABA: '234334789',
-      })
-      expect(created['Id']).not_to be_nil
-      expect(created['Type']).to eq('US')
-      expect(created['AccountNumber']).to eq('234234234234')
-      expect(created['ABA']).to eq('234334789')
-    end
-
-    it 'creates a new CA bank detail' do
-      created = create({
-        Type: 'CA',
-        BankName: 'TestBankName',
-        BranchCode: '12345',
-        AccountNumber: '234234234234',
-        InstitutionNumber: '123',
-      })
-      expect(created['Id']).not_to be_nil
-      expect(created['Type']).to eq('CA')
-      expect(created['BankName']).to eq('TestBankName')
-      expect(created['BranchCode']).to eq('12345')
-      expect(created['AccountNumber']).to eq('234234234234')
-      expect(created['InstitutionNumber']).to eq('123')
-    end
-
-    it 'creates a new OTHER bank detail' do
-      created = create({
-        Type: 'OTHER',
-        Country: 'FR',
-        AccountNumber: '234234234234',
-        BIC: 'BINAADADXXX',
-      })
-      expect(created['Id']).not_to be_nil
-      expect(created['Type']).to eq('OTHER')
-      expect(created['Country']).to eq('FR')
-      expect(created['AccountNumber']).to eq('234234234234')
-      expect(created['BIC']).to eq('BINAADADXXX')
-    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
-
-  describe 'UPDATE' do
-    it 'disactivates a bank account' do
-      usr_id = new_bank_account['UserId']
-      acc_id = new_bank_account['Id']
-
-      changed = MangoPay::BankAccount.update(usr_id, acc_id, {Active: false})
-      fetched = MangoPay::BankAccount.fetch(usr_id, acc_id)
-      expect(changed['Active']).to eq(false)
-      expect(fetched['Active']).to eq(false)
-    end
-  end
-end
+describe MangoPay::BankAccount do
+  include_context 'bank_accounts'
+
+  def create(params)
+    user = new_natural_user
+    params_fixed = { OwnerName: 'John', OwnerAddress: user['Address'] }.merge(params)
+    MangoPay::BankAccount.create(user['Id'], params_fixed)
+  end
+
+  describe 'CREATE' do
+
+    it 'creates a new IBAN bank detail' do
+      expect(new_bank_account['Id']).not_to be_nil
+    end
+
+    it 'creates a new GB bank detail' do
+      created = create({
+        Type: 'GB',
+        AccountNumber: '63956474',
+        SortCode: '200000',
+      })
+      expect(created['Id']).not_to be_nil
+      expect(created['Type']).to eq('GB')
+      expect(created['AccountNumber']).to eq('63956474')
+      expect(created['SortCode']).to eq('200000')
+    end
+
+    it 'creates a new US bank detail' do
+      created = create({
+        Type: 'US',
+        AccountNumber: '234234234234',
+        ABA: '234334789',
+      })
+      expect(created['Id']).not_to be_nil
+      expect(created['Type']).to eq('US')
+      expect(created['AccountNumber']).to eq('234234234234')
+      expect(created['ABA']).to eq('234334789')
+    end
+
+    it 'creates a new CA bank detail' do
+      created = create({
+        Type: 'CA',
+        BankName: 'TestBankName',
+        BranchCode: '12345',
+        AccountNumber: '234234234234',
+        InstitutionNumber: '123',
+      })
+      expect(created['Id']).not_to be_nil
+      expect(created['Type']).to eq('CA')
+      expect(created['BankName']).to eq('TestBankName')
+      expect(created['BranchCode']).to eq('12345')
+      expect(created['AccountNumber']).to eq('234234234234')
+      expect(created['InstitutionNumber']).to eq('123')
+    end
+
+    it 'creates a new OTHER bank detail' do
+      created = create({
+        Type: 'OTHER',
+        Country: 'FR',
+        AccountNumber: '234234234234',
+        BIC: 'BINAADADXXX',
+      })
+      expect(created['Id']).not_to be_nil
+      expect(created['Type']).to eq('OTHER')
+      expect(created['Country']).to eq('FR')
+      expect(created['AccountNumber']).to eq('234234234234')
+      expect(created['BIC']).to eq('BINAADADXXX')
+    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
+
+  describe 'UPDATE' do
+    it 'disactivates a bank account' do
+      usr_id = new_bank_account['UserId']
+      acc_id = new_bank_account['Id']
+
+      changed = MangoPay::BankAccount.update(usr_id, acc_id, {Active: false})
+      fetched = MangoPay::BankAccount.fetch(usr_id, acc_id)
+      expect(changed['Active']).to eq(false)
+      expect(fetched['Active']).to eq(false)
+    end
+  end
+end

data/spec/mangopay/card_registration_spec.rb

@@ -1,73 +1,73 @@
-describe MangoPay::CardRegistration do
-  include_context 'users'
-  include_context 'payins'
-
-  describe 'CREATE' do
-    it 'creates a new card registration' do
-      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
-      created = new_card_registration
-      updated = MangoPay::CardRegistration.update(created['Id'] ,{
-        RegistrationData: 'test RegistrationData'
-      })
-      expect(updated['RegistrationData']).to eq('test RegistrationData')
-    end
-  end
-
-  describe 'FETCH' do
-    it 'fetches a card registration' do
-      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
-
-################################################################################
-# cannot test updating: one can only put a CARD from "VALID" to "INVALID"
-#      # let's test updating the card too
-#      expect(card['Validity']).to eq 'UNKNOWN'
-#      card_updated = MangoPay::Card.update(card_id ,{
-#        Validity: 'INVALID'
-#      })
-#      expect(card_updated['Validity']).to eq 'INVALID'
-#      expect(MangoPay::Card.fetch(card_id)['Validity']).to eq 'INVALID'
-################################################################################
-    end
-  end
-
-end
+describe MangoPay::CardRegistration do
+  include_context 'users'
+  include_context 'payins'
+
+  describe 'CREATE' do
+    it 'creates a new card registration' do
+      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
+      created = new_card_registration
+      updated = MangoPay::CardRegistration.update(created['Id'] ,{
+        RegistrationData: 'test RegistrationData'
+      })
+      expect(updated['RegistrationData']).to eq('test RegistrationData')
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a card registration' do
+      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
+
+################################################################################
+# cannot test updating: one can only put a CARD from "VALID" to "INVALID"
+#      # let's test updating the card too
+#      expect(card['Validity']).to eq 'UNKNOWN'
+#      card_updated = MangoPay::Card.update(card_id ,{
+#        Validity: 'INVALID'
+#      })
+#      expect(card_updated['Validity']).to eq 'INVALID'
+#      expect(MangoPay::Card.fetch(card_id)['Validity']).to eq 'INVALID'
+################################################################################
+    end
+  end
+
+end