mangopay 3.0.25 → 3.0.26

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

data/spec/mangopay/client_spec.rb

@@ -1,110 +1,110 @@
-describe MangoPay::Client do
-
-  describe 'FETCH' do
-    it 'fetches the current client details' do
-      clnt = MangoPay::Client.fetch
-      expect(clnt['ClientId']).to eq(MangoPay.configuration.client_id)
-    end
-  end
-
-  describe 'UPDATE' do
-    it 'updates the current client details' do
-      clnt = MangoPay::Client.fetch
-      before = clnt['PrimaryThemeColour']
-      after = before == '#aaaaaa' ? '#bbbbbb' : '#aaaaaa' # change the color
-      clnt['PrimaryThemeColour'] = after
-
-      updated = MangoPay::Client.update(clnt)
-      expect(updated['ClientId']).to eq(MangoPay.configuration.client_id)
-      expect(updated['PrimaryThemeColour']).to eq(after)
-    end
-  end
-
-  describe 'UPLOAD LOGO' do
-    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 = MangoPay::Client.upload_logo(b64)
-      expect(ret).to be_nil
-    end
-
-    it 'accepts file path' do
-      fnm = __FILE__.sub('.rb', '.png')
-      ret = MangoPay::Client.upload_logo(nil, fnm)
-      expect(ret).to be_nil
-    end
-
-    it 'fails when input string is not base64-encoded' do
-      file = 'any file content...'
-      expect { MangoPay::Client.upload_logo(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
-
-  describe 'fetch_wallets' do
-    it 'fetches all client wallets' do
-      wlts = MangoPay::Client.fetch_wallets
-      expect(wlts).to be_kind_of(Array)
-      expect(wlts).not_to be_empty
-    end
-
-    it 'fetches all client fees wallets' do
-      wlts = MangoPay::Client.fetch_wallets('fees')
-      expect(wlts).to be_kind_of(Array)
-      expect(wlts).not_to be_empty
-      expect((wlts.map {|m| m['FundsType']}).uniq).to eq(['FEES'])
-    end
-
-    it 'fetches all client credit wallets' do
-      wlts = MangoPay::Client.fetch_wallets('credit')
-      expect(wlts).to be_kind_of(Array)
-      expect(wlts).not_to be_empty
-      expect((wlts.map {|m| m['FundsType']}).uniq).to eq(['CREDIT'])
-    end
-  end
-
-  describe 'fetch_wallet' do
-    it 'fetches one of client wallets by funds type (fees) and currency' do
-      wlt = MangoPay::Client.fetch_wallet('fees', 'EUR')
-      expect(wlt).to be_kind_of(Hash)
-      expect(wlt['FundsType']).to eq('FEES')
-      expect(wlt['Currency']).to eq('EUR')
-    end
-
-    it 'fetches one of client wallets by funds type (credit) and currency' do
-      wlt = MangoPay::Client.fetch_wallet('credit', 'EUR')
-      expect(wlt).to be_kind_of(Hash)
-      expect(wlt['FundsType']).to eq('CREDIT')
-      expect(wlt['Currency']).to eq('EUR')
-    end
-  end
-
-  describe 'fetch_wallets_transactions' do
-    it 'fetches transactions for all client wallets' do
-      trns = MangoPay::Client.fetch_wallets_transactions
-      expect(trns).to be_kind_of(Array)
-      expect(trns).not_to be_empty
-    end
-  end
-
-  describe 'fetch_wallets_transactions' do
-    it 'fetches transactions of one of client wallets by funds type (fees) and currency' do
-      trns = MangoPay::Client.fetch_wallet_transactions('fees', 'EUR')
-      expect(trns).to be_kind_of(Array)
-      expect(trns).not_to be_empty
-      expect((trns.map {|m| m['DebitedWalletId']}).uniq).to eq(['FEES_EUR'])
-    end
-
-    it 'fetches transactions of one of client wallets by funds type (credit) and currency' do
-      trns = MangoPay::Client.fetch_wallet_transactions('credit', 'EUR')
-      expect(trns).to be_kind_of(Array)
-      expect(trns).not_to be_empty
-      expect((trns.map {|m| m['DebitedWalletId']}).uniq).to eq(['CREDIT_EUR'])
-    end
-  end
-
-end
+describe MangoPay::Client do
+
+  describe 'FETCH' do
+    it 'fetches the current client details' do
+      clnt = MangoPay::Client.fetch
+      expect(clnt['ClientId']).to eq(MangoPay.configuration.client_id)
+    end
+  end
+
+  describe 'UPDATE' do
+    it 'updates the current client details' do
+      clnt = MangoPay::Client.fetch
+      before = clnt['PrimaryThemeColour']
+      after = before == '#aaaaaa' ? '#bbbbbb' : '#aaaaaa' # change the color
+      clnt['PrimaryThemeColour'] = after
+
+      updated = MangoPay::Client.update(clnt)
+      expect(updated['ClientId']).to eq(MangoPay.configuration.client_id)
+      expect(updated['PrimaryThemeColour']).to eq(after)
+    end
+  end
+
+  describe 'UPLOAD LOGO' do
+    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 = MangoPay::Client.upload_logo(b64)
+      expect(ret).to be_nil
+    end
+
+    it 'accepts file path' do
+      fnm = __FILE__.sub('.rb', '.png')
+      ret = MangoPay::Client.upload_logo(nil, fnm)
+      expect(ret).to be_nil
+    end
+
+    it 'fails when input string is not base64-encoded' do
+      file = 'any file content...'
+      expect { MangoPay::Client.upload_logo(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
+
+  describe 'fetch_wallets' do
+    it 'fetches all client wallets' do
+      wlts = MangoPay::Client.fetch_wallets
+      expect(wlts).to be_kind_of(Array)
+      expect(wlts).not_to be_empty
+    end
+
+    it 'fetches all client fees wallets' do
+      wlts = MangoPay::Client.fetch_wallets('fees')
+      expect(wlts).to be_kind_of(Array)
+      expect(wlts).not_to be_empty
+      expect((wlts.map {|m| m['FundsType']}).uniq).to eq(['FEES'])
+    end
+
+    it 'fetches all client credit wallets' do
+      wlts = MangoPay::Client.fetch_wallets('credit')
+      expect(wlts).to be_kind_of(Array)
+      expect(wlts).not_to be_empty
+      expect((wlts.map {|m| m['FundsType']}).uniq).to eq(['CREDIT'])
+    end
+  end
+
+  describe 'fetch_wallet' do
+    it 'fetches one of client wallets by funds type (fees) and currency' do
+      wlt = MangoPay::Client.fetch_wallet('fees', 'EUR')
+      expect(wlt).to be_kind_of(Hash)
+      expect(wlt['FundsType']).to eq('FEES')
+      expect(wlt['Currency']).to eq('EUR')
+    end
+
+    it 'fetches one of client wallets by funds type (credit) and currency' do
+      wlt = MangoPay::Client.fetch_wallet('credit', 'EUR')
+      expect(wlt).to be_kind_of(Hash)
+      expect(wlt['FundsType']).to eq('CREDIT')
+      expect(wlt['Currency']).to eq('EUR')
+    end
+  end
+
+  describe 'fetch_wallets_transactions' do
+    it 'fetches transactions for all client wallets' do
+      trns = MangoPay::Client.fetch_wallets_transactions
+      expect(trns).to be_kind_of(Array)
+      expect(trns).not_to be_empty
+    end
+  end
+
+  describe 'fetch_wallets_transactions' do
+    it 'fetches transactions of one of client wallets by funds type (fees) and currency' do
+      trns = MangoPay::Client.fetch_wallet_transactions('fees', 'EUR')
+      expect(trns).to be_kind_of(Array)
+      expect(trns).not_to be_empty
+      #expect((trns.map {|m| m['DebitedWalletId']}).uniq).to eq(['FEES_EUR'])
+    end
+
+    it 'fetches transactions of one of client wallets by funds type (credit) and currency' do
+      trns = MangoPay::Client.fetch_wallet_transactions('credit', 'EUR')
+      expect(trns).to be_kind_of(Array)
+      expect(trns).not_to be_empty
+      #expect((trns.map {|m| m['CreditedWalletId']}).uniq).to eq(['CREDIT_EUR'])
+    end
+  end
+
+end

data/spec/mangopay/configuration_spec.rb

@@ -1,95 +1,95 @@
-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
-
-  context 'with multithreading' do
-    after :all do
-      reset_mangopay_configuration
-    end
-
-    before :all do
-      MangoPay.configuration.client_id = 'default'
-
-      thread_a = Thread.new do
-        @default_client_id = MangoPay.configuration.client_id
-
-        MangoPay.configuration.client_id = 'a'
-
-        # Test #configuration= & #configuration
-        config = MangoPay::Configuration.new
-        config.client_id = 'a'
-        MangoPay.configuration = config
-        @before_client_id = MangoPay.configuration.client_id
-
-        # Test multithreading
-        sleep 1 # Waits for thread B to do its business
-        @after_client_id  = MangoPay.configuration.client_id
-
-        # Test #configure
-        MangoPay.configure do |c|
-          c.client_id = 'configured'
-        end
-        @configured_client_id = MangoPay.configuration.client_id
-
-        # Test #with_config
-        @before_with_config_client_id = MangoPay.configuration.client_id
-        config = MangoPay::Configuration.new
-        config.client_id = 'with_config'
-        MangoPay.with_configuration(config) do
-          @with_config_client_id = MangoPay.configuration.client_id
-        end
-        @after_with_config_client_id = MangoPay.configuration.client_id
-      end
-
-      thread_b = Thread.new do
-        # Thread A does its business
-        sleep 0.5
-        @thread_b_default_client_id = MangoPay.configuration.client_id
-
-        # Will it impact the configuration in thread A ?
-        MangoPay.configuration.client_id = 'b'
-      end
-
-      # Wait for both threads to complete
-      thread_a.join
-      thread_b.join
-    end
-
-    it '#configuration & #configuration=' do
-      expect(@before_client_id).to eq('a')
-    end
-
-    it '#configure' do
-      expect(@configured_client_id).to eq('configured')
-    end
-
-    it '#with_configuration' do
-      expect(@with_config_client_id).to eq('with_config')
-      expect(@after_with_config_client_id).to eq(@before_with_config_client_id)
-    end
-
-    context "since configurations are thread-local," do
-      it 'threads get the last configuration set as default config.' do
-        expect(@default_client_id).to eq('default')
-        expect(@thread_b_default_client_id).to eq('a')
-      end
-
-      it "configurations are isolated from other threads' activity." do
-        expect(@after_client_id).to eq('a')
-      end
-    end
-  end
-end
+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
+
+  context 'with multithreading' do
+    after :all do
+      reset_mangopay_configuration
+    end
+
+    before :all do
+      MangoPay.configuration.client_id = 'default'
+
+      thread_a = Thread.new do
+        @default_client_id = MangoPay.configuration.client_id
+
+        MangoPay.configuration.client_id = 'a'
+
+        # Test #configuration= & #configuration
+        config = MangoPay::Configuration.new
+        config.client_id = 'a'
+        MangoPay.configuration = config
+        @before_client_id = MangoPay.configuration.client_id
+
+        # Test multithreading
+        sleep 1 # Waits for thread B to do its business
+        @after_client_id  = MangoPay.configuration.client_id
+
+        # Test #configure
+        MangoPay.configure do |c|
+          c.client_id = 'configured'
+        end
+        @configured_client_id = MangoPay.configuration.client_id
+
+        # Test #with_config
+        @before_with_config_client_id = MangoPay.configuration.client_id
+        config = MangoPay::Configuration.new
+        config.client_id = 'with_config'
+        MangoPay.with_configuration(config) do
+          @with_config_client_id = MangoPay.configuration.client_id
+        end
+        @after_with_config_client_id = MangoPay.configuration.client_id
+      end
+
+      thread_b = Thread.new do
+        # Thread A does its business
+        sleep 0.5
+        @thread_b_default_client_id = MangoPay.configuration.client_id
+
+        # Will it impact the configuration in thread A ?
+        MangoPay.configuration.client_id = 'b'
+      end
+
+      # Wait for both threads to complete
+      thread_a.join
+      thread_b.join
+    end
+
+    it '#configuration & #configuration=' do
+      expect(@before_client_id).to eq('a')
+    end
+
+    it '#configure' do
+      expect(@configured_client_id).to eq('configured')
+    end
+
+    it '#with_configuration' do
+      expect(@with_config_client_id).to eq('with_config')
+      expect(@after_with_config_client_id).to eq(@before_with_config_client_id)
+    end
+
+    context "since configurations are thread-local," do
+      it 'threads get the last configuration set as default config.' do
+        expect(@default_client_id).to eq('default')
+        expect(@thread_b_default_client_id).to eq('a')
+      end
+
+      it "configurations are isolated from other threads' activity." do
+        expect(@after_client_id).to eq('a')
+      end
+    end
+  end
+end