mangopay4-ruby-sdk 3.52.0 → 4.0.0

data/spec/mangopay/client_spec.rb

@@ -1,213 +0,0 @@
-describe MangoPay::Client do
-  include_context 'users'
-  include_context 'payins'
-
-  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 'FETCH' do
-    it "fetches the client headquarter's phone number" do
-      client = MangoPay::Client.fetch
-      expect(client['HeadquartersPhoneNumber']).to_not be_nil
-    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
-      clnt['HeadquartersAddress'] = {
-          AddressLine1: 'Rue Dandelion, n. 17',
-          City: 'Lyon',
-          Country: 'FR',
-          PostalCode: '150770'
-      }
-      clnt['TechEmails'] = ['support@mangopay.com']
-      phoneNumber = rand(99999999).to_s
-      clnt['HeadquartersPhoneNumber'] = phoneNumber
-
-      updated = MangoPay::Client.update(clnt)
-      expect(updated['ClientId']).to eq(MangoPay.configuration.client_id)
-      expect(updated['PrimaryThemeColour']).to eq(after)
-      expect(updated['HeadquartersPhoneNumber']).to eq(phoneNumber)
-    end
-  end
-
-  describe 'UPLOAD LOGO' do
-    xit '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_not be_nil
-    end
-
-    xit 'accepts file path' do
-      fnm = __FILE__.sub('.rb', '.png')
-      ret = MangoPay::Client.upload_logo(nil, fnm)
-      expect(ret).to_not 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
-      pending("Endpoint removed")
-      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
-
-  # describe 'validate' do
-  #   it 'validates card' do
-  #     client = MangoPay::Client.fetch
-  #     completed = new_card_registration_completed
-  #     card_id = completed['CardId']
-  #     client_id = client['ClientId']
-  #
-  #     card = MangoPay::Client.validate(client_id, card_id)
-  #     expect(client).not_to be_nil
-  #     expect(card).not_to be_nil
-  #   end
-  # end
-
-  describe 'create_bank_account' do
-    it 'creates a new bank account' do
-      bank_account = MangoPay::Client.create_bank_account(Type: 'IBAN',
-                                                          OwnerName: 'John',
-                                                          OwnerAddress: {
-                                                              AddressLine1: 'Le Palais Royal',
-                                                              AddressLine2: '8 Rue de Montpensier',
-                                                              City: 'Paris',
-                                                              Region: '',
-                                                              PostalCode: '75001',
-                                                              Country: 'FR'
-                                                          },
-                                                          IBAN: 'FR7630004000031234567890143',
-                                                          BIC: 'BNPAFRPP',
-                                                          Tag: 'Test bank account')
-      expect(bank_account).not_to be_nil
-      expect(bank_account['Id']).not_to be_nil
-    end
-  end
-
-  describe 'create_payout' do
-    it 'creates a new payout' do
-      wallets = MangoPay::Client.fetch_wallets('FEES')
-      bank_account = MangoPay::Client.create_bank_account(Type: 'IBAN',
-                                                          OwnerName: 'John',
-                                                          OwnerAddress: {
-                                                              AddressLine1: 'Le Palais Royal',
-                                                              AddressLine2: '8 Rue de Montpensier',
-                                                              City: 'Paris',
-                                                              Region: '',
-                                                              PostalCode: '75001',
-                                                              Country: 'FR'
-                                                          },
-                                                          IBAN: 'FR7630004000031234567890143',
-                                                          BIC: 'BNPAFRPP',
-                                                          Tag: 'Test bank account')
-      pay_out = MangoPay::Client.create_payout(BankAccountId: bank_account['Id'],
-
-                                               DebitedFunds: {
-                                                   Currency: 'EUR',
-                                                   Amount: 12
-                                               },
-                                               DebitedWalletId: wallets[0]['Id'],
-                                               BankWireRef: 'invoice 7282',
-                                               PayoutModeRequested: 'STANDARD',
-                                               Tag: 'bla')
-
-      expect(pay_out).not_to be_nil
-      expect(pay_out['Id']).not_to be_nil
-    end
-  end
-
-  describe 'create payin bankwire direct' do
-    it 'creates the payin' do
-      dto = {
-        "CreditedWalletId": "CREDIT_EUR",
-        "DeclaredDebitedFunds": {
-          "Currency": "EUR",
-          "Amount": 1000
-        }
-      }
-      created = MangoPay::Client.create_bank_wire_direct_pay_in(dto)
-      expect(created).not_to be_nil
-      expect(created['Id']).not_to be_nil
-      expect(created['Type']).to eq('PAYIN')
-      expect(created['Status']).to eq('CREATED')
-      expect(created['PaymentType']).to eq('BANK_WIRE')
-      expect(created['ExecutionType']).to eq('DIRECT')
-    end
-  end
-end

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,120 +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
-
-    it 'creates a new paypal deposit preauthorization' do
-      author = new_natural_user
-      preauthorization = create_new_paypal_deposit_preauthorization(author['Id'])
-
-      expect(preauthorization['Id']).not_to be_nil
-      expect(preauthorization['PaymentType']).to eq('PAYPAL')
-      expect(preauthorization['Status']).to eq('CREATED')
-      expect(preauthorization['PaymentStatus']).to eq('WAITING')
-      expect(preauthorization['Reference']).not_to be_nil
-      expect(preauthorization['LineItems']).not_to be_nil
-      expect(preauthorization['ShippingPreference']).not_to be_nil
-    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