mangopay4-ruby-sdk 3.47.0 → 4.1.0

data/spec/mangopay/configuration_spec.rb

@@ -1,249 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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['RequestedFees']['Value']).not_to be_nil
-      expect(conversion['Status']).equal? 'SUCCEEDED'
-      expect(conversion['MarginsResponse']['Mangopay']).not_to be_nil
-      expect(conversion['MarginsResponse']['User']).to be_nil
-    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_with_fees
-      expect(conversion_quote['DebitedFunds']).not_to be_nil
-      expect(conversion_quote['CreditedFunds']).not_to be_nil
-      expect(conversion_quote['Duration']).equal? 90
-      expect(conversion_quote['Fees']['Amount']).not_to be_nil
-      expect(conversion_quote['RequestedFees']['Value']).not_to be_nil
-      expect(conversion_quote['MarginsResponse']['Mangopay']).not_to be_nil
-      expect(conversion_quote['MarginsResponse']['User']).not_to be_nil
-    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

@@ -1,107 +0,0 @@
-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