mangopay4-ruby-sdk 3.44.0

data/spec/mangopay/configuration_spec.rb

@@ -0,0 +1,249 @@
+describe MangoPay::Configuration do
+
+  it 'fails when calling with wrong client credentials' do
+    expect {
+      c = MangoPay.configuration
+      c.client_id = 'test_asd'
+      c.client_apiKey = '00000'
+      MangoPay::User.fetch()
+    }.to raise_error { |err|
+        expect(err).to be_a MangoPay::ResponseError
+        expect(err.code).to eq '401'
+        expect(err.message).to eq 'invalid_client'
+      }
+  end
+
+  it 'fails when calling with wrong client credentials, but succeeds after applying a new (correct) config' do
+    # create a wrong configuration
+    wrong_config = MangoPay::Configuration.new
+    wrong_config.client_id = 'placeholder'
+    wrong_config.client_apiKey = '0000'
+    wrong_config.preproduction = true
+
+    # create a valid configuration
+    valid_config = MangoPay::Configuration.new
+    valid_config.client_id = 'sdk-unit-tests'
+    valid_config.client_apiKey = 'cqFfFrWfCcb7UadHNxx2C9Lo6Djw8ZduLi7J9USTmu8bhxxpju'
+    valid_config.preproduction = true
+
+    # add the 2 configs to the list of MangoPay configs
+    MangoPay.add_config('wrong', wrong_config)
+    MangoPay.add_config('valid', valid_config)
+
+    # apply wrong config
+    MangoPay.get_config('wrong').apply_configuration
+
+    expect {
+      MangoPay::User.fetch()
+    }.to raise_error { |err|
+      expect(err).to be_a MangoPay::ResponseError
+      expect(err.code).to eq '401'
+      expect(err.message).to eq 'invalid_client'
+    }
+
+    # apply valid configuration
+    MangoPay.get_config('valid').apply_configuration
+
+    # expect success
+    users = MangoPay::User.fetch()
+    expect(users).to be_kind_of(Array)
+  end
+
+  it 'fails when fetching a config that does not exist' do
+    expect {
+      MangoPay.get_config('placeholder')
+    }.to raise_error { |err|
+      expect(err).to be_a RuntimeError
+      expect(err.message).to eq "Could not find any configuration with name 'placeholder'"
+    }
+  end
+
+  it 'succeeds when removing config' do
+    wrong_config = MangoPay::Configuration.new
+    wrong_config.client_id = 'placeholder'
+    wrong_config.client_apiKey = '0000'
+    wrong_config.preproduction = true
+
+    MangoPay.add_config('wrong', wrong_config)
+
+    # pass when fetching config before removing it
+    MangoPay.get_config('wrong')
+
+    # remove config
+    MangoPay.remove_config('wrong')
+
+    # fail when trying to fetch after removal
+    expect {
+      MangoPay.get_config('wrong')
+    }.to raise_error { |err|
+      expect(err).to be_a RuntimeError
+      expect(err.message).to eq "Could not find any configuration with name 'wrong'"
+    }
+  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
+
+  describe '.use_ssl?' do
+    let(:configuration) { MangoPay::Configuration.new }
+
+    it 'defaults to true' do
+      expect(configuration.use_ssl?).to eq(true)
+    end
+
+    context 'when assigned to false in production' do
+      before do
+        configuration.use_ssl = false
+        configuration.preproduction = false
+      end
+
+      it 'uses true as value' do
+        expect(configuration.use_ssl?).to eq(true)
+      end
+    end
+
+    context 'when assigned to false in preproduction' do
+      before do
+        configuration.use_ssl = false
+        configuration.preproduction = true
+      end
+
+      it 'uses assigned as value' do
+        expect(configuration.use_ssl?).to eq(false)
+      end
+    end
+  end
+
+  describe 'logger' do
+    around(:each) do |example|
+      c = MangoPay.configuration
+      c.logger = logger
+      c.log_file = log_file
+      example.run
+      c.logger = nil
+      c.log_file = nil
+      MangoPay.instance_variable_set(:@logger, nil)
+    end
+
+    context 'when the logger is set' do
+      let(:logger) { Logger.new(STDOUT) }
+
+      context 'when the log_file is set' do
+        let(:log_file) { File.join(MangoPay.configuration.temp_dir, 'mangopay.log.tmp') }
+
+        it 'initializes the logger using the logger option' do
+          expect(MangoPay.send(:logger).instance_variable_get(:@logdev).dev).to(eq(STDOUT))
+        end
+      end
+
+      context 'when the log_file is not set' do
+        let(:log_file) { nil }
+
+        it 'initializes the logger using the logger option' do
+          expect(MangoPay.send(:logger).instance_variable_get(:@logdev).dev).to(eq(STDOUT))
+        end
+      end
+    end
+
+    context 'when the logger is not set' do
+      let(:logger) { nil }
+
+      context 'when the log_file is set' do
+        let(:log_file) { File.join(MangoPay.configuration.temp_dir, 'mangopay.log.tmp') }
+
+        it 'initializes the logger using the log file' do
+          expect(MangoPay.send(:logger).instance_variable_get(:@logdev).dev).to(be_an_instance_of(File))
+        end
+      end
+
+      context 'when the log_file is not set' do
+        let(:log_file) { nil }
+
+        it 'raises an error' do
+          expect{ MangoPay.send(:logger) }.to raise_error NotImplementedError
+        end
+      end
+    end
+  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

data/spec/mangopay/conversion_spec.rb

@@ -0,0 +1,96 @@
+describe MangoPay::Conversion, type: :feature do
+  include_context 'instant_conversion'
+
+  describe 'GET CONVERSION RATE' do
+    it 'get a conversion rate' do
+      conversion_rate = get_conversion_rate('EUR','GBP')
+
+      expect(conversion_rate['ClientRate']).not_to be_nil
+      expect(conversion_rate['MarketRate']).not_to be_nil
+    end
+  end
+
+  describe 'CREATE INSTANT CONVERSION' do
+    it 'creates a new instant conversion' do
+      conversion = create_instant_conversion
+
+      expect(conversion['DebitedFunds']['Amount']).not_to be_nil
+      expect(conversion['CreditedFunds']['Amount']).not_to be_nil
+      expect(conversion['Fees']['Amount']).not_to be_nil
+      expect(conversion['Status']).equal? 'SUCCEEDED'
+    end
+  end
+
+  describe 'CREATE QUOTED CONVERSION' do
+    it 'creates a new quoted conversion' do
+      conversion = create_quoted_conversion
+
+      expect(conversion['DebitedFunds']['Amount']).not_to be_nil
+      expect(conversion['CreditedFunds']['Amount']).not_to be_nil
+      expect(conversion['Status']).equal? 'SUCCEEDED'
+    end
+  end
+
+  describe 'CREATE QUOTED CONVERSION BETWEEN CLIENT WALLETS' do
+    it 'creates a new quoted conversion' do
+      quote = create_conversion_quote
+
+      conversion = MangoPay::Conversion.create_client_wallets_quoted_conversion(
+        QuoteId: quote['Id'],
+        CreditedWalletType: 'CREDIT',
+        DebitedWalletType: 'FEES'
+      )
+
+      expect(conversion['Status']).equal? 'SUCCEEDED'
+    end
+  end
+
+  describe 'CREATE INSTANT CONVERSION BETWEEN CLIENT WALLETS' do
+    it 'creates a new quoted conversion' do
+      conversion = MangoPay::Conversion.create_client_wallets_instant_conversion(
+        CreditedWalletType: 'FEES',
+        DebitedWalletType: 'FEES',
+        DebitedFunds: {
+          Currency: 'GBP',
+          Amount: 79
+        },
+        CreditedFunds: {
+          Currency: 'EUR'
+        }
+      )
+
+      expect(conversion['Status']).equal? 'SUCCEEDED'
+    end
+  end
+
+  describe 'GET EXISTING CONVERSION' do
+    it 'get an existing conversion' do
+      conversion = create_instant_conversion
+      returned_conversion = get_conversion(conversion['Id'])
+
+      expect(returned_conversion['DebitedFunds']['Amount']).not_to be_nil
+      expect(returned_conversion['CreditedFunds']['Amount']).not_to be_nil
+      expect(conversion['Fees']['Amount']).not_to be_nil
+      expect(returned_conversion['Status']).equal? 'SUCCEEDED'
+    end
+  end
+
+  describe 'CREATE CONVERSION QUOTE' do
+    it 'create a conversion quote' do
+      conversion_quote = create_conversion_quote
+      expect(conversion_quote['DebitedFunds']).not_to be_nil
+      expect(conversion_quote['CreditedFunds']).not_to be_nil
+      expect(conversion_quote['Duration']).equal? 90
+    end
+  end
+
+  describe 'GET CONVERSION QUOTE' do
+    it 'get a conversion quote' do
+      conversion_quote = create_conversion_quote
+      returned_conversion_quote = get_conversion_quote(conversion_quote['Id'])
+      expect(returned_conversion_quote['DebitedFunds']).not_to be_nil
+      expect(returned_conversion_quote['CreditedFunds']).not_to be_nil
+      expect(returned_conversion_quote['Duration']).equal? 90
+    end
+  end
+end

data/spec/mangopay/deposit_spec.rb

@@ -0,0 +1,107 @@
+describe MangoPay::Deposit do
+  include_context 'users'
+  include_context 'payins'
+
+  describe 'CREATE' do
+    it 'creates a new deposit' do
+      author = new_natural_user
+      card_registration = new_card_registration_completed
+      deposit = create_new_deposit(card_registration['CardId'], author['Id'])
+
+      assert_deposit(deposit, card_registration['CardId'], author["Id"])
+    end
+  end
+
+  describe 'GET' do
+    it 'get an existing deposit' do
+      author = new_natural_user
+      card_registration = new_card_registration_completed
+      deposit = create_new_deposit(card_registration['CardId'], author['Id'])
+
+      assert_deposit(deposit, card_registration['CardId'], author["Id"])
+
+      fetched_deposit = MangoPay::Deposit.get(deposit['Id'])
+
+      assert_deposit(fetched_deposit, card_registration['CardId'], author["Id"])
+    end
+
+    it 'gets all deposits for a user' do
+      author = new_natural_user
+      card_registration = new_card_registration_completed
+      create_new_deposit(card_registration['CardId'], author['Id'])
+
+      result = MangoPay::Deposit.get_all_for_user(author['Id'])
+      expect(result).to be_kind_of(Array)
+      expect(result.count).to be > 0
+    end
+
+    it 'gets all deposits for a card' do
+      author = new_natural_user
+      card_registration = new_card_registration_completed
+      create_new_deposit(card_registration['CardId'], author['Id'])
+
+      result = MangoPay::Deposit.get_all_for_card(card_registration['CardId'])
+      expect(result).to be_kind_of(Array)
+      expect(result.count).to be > 0
+    end
+
+    it 'fetches transactions for a deposit' do
+      author = new_natural_user
+      wallet = new_wallet
+      card_registration = new_card_registration_completed
+      deposit = create_new_deposit(card_registration['CardId'], author['Id'])
+      create_new_payin_pre_authorized_deposit_direct(deposit['Id'], author['Id'], wallet['Id'])
+
+      transactions = MangoPay::Deposit.get_transactions(deposit['Id'])
+      expect(transactions).to be_kind_of(Array)
+      expect(transactions.count).to be > 0
+    end
+  end
+
+# the Cancel flow will be teste manually for now
+=begin
+  describe 'CANCEL' do
+    it 'cancel an existing deposit' do
+      author = new_natural_user
+      card_registration = new_card_registration_completed
+      deposit = create_new_deposit(card_registration['CardId'], author['Id'])
+
+      assert_deposit(deposit, card_registration['CardId'], author["Id"])
+      expect(deposit['Status']).to eq('CREATED')
+      expect(deposit['PaymentStatus']).to eq('WAITING')
+
+      MangoPay::Deposit.cancel(deposit['Id'])
+
+      updated_deposit = MangoPay::Deposit.get(deposit['Id'])
+
+      assert_deposit(updated_deposit, card_registration['CardId'], author["Id"])
+      expect(updated_deposit['Status']).to eq('SUCCEEDED')
+      expect(updated_deposit['PaymentStatus']).to eq('CANCELED')
+    end
+  end
+=end
+end
+
+
+def assert_deposit(deposit, card_reg_id, author_id)
+  expect(deposit['Id']).not_to be_nil
+  expect(deposit['CreationDate']).not_to be_nil
+  expect(deposit['ExpirationDate']).not_to be_nil
+  expect(deposit['AuthorId']).not_to be_nil
+  expect(deposit['DebitedFunds']).not_to be_nil
+  expect(deposit['Status']).not_to be_nil
+  expect(deposit['PaymentStatus']).not_to be_nil
+  expect(deposit['PayinsLinked']).not_to be_nil
+  expect(deposit['CardId']).not_to be_nil
+  expect(deposit['CardId']).to eq(card_reg_id)
+  expect(deposit['AuthorId']).to eq(author_id)
+  expect(deposit['SecureModeReturnURL']).not_to be_nil
+  expect(deposit['PaymentType']).not_to be_nil
+  expect(deposit['ExecutionType']).not_to be_nil
+  expect(deposit['StatementDescriptor']).not_to be_nil
+  expect(deposit['Culture']).not_to be_nil
+  expect(deposit['BrowserInfo']).not_to be_nil
+  expect(deposit['IpAddress']).not_to be_nil
+  expect(deposit['Billing']).not_to be_nil
+  expect(deposit['Shipping']).not_to be_nil
+end