mangopay4-ruby-sdk 3.44.0

data/spec/mangopay/authorization_token_spec.rb

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

data/spec/mangopay/bank_account_spec.rb

@@ -0,0 +1,105 @@
+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
+
+  describe 'FETCH Transaction' do
+    it "fetches a bank account's transactions" do
+      bank_account = new_bank_account
+      transactions = MangoPay::BankAccount.transactions(bank_account['Id'])
+      expect(transactions).to be_an(Array)
+    end
+  end
+end

data/spec/mangopay/bankingaliases_spec.rb

@@ -0,0 +1,29 @@
+describe MangoPay::BankingAliases do
+  include_context 'users'
+  include_context 'wallets'
+  include_context 'bankingaliases'
+
+  describe 'CREATE' do
+    it 'creates a new banking alias' do
+      expect(new_banking_alias['CreditedUserId']).to eq(new_natural_user['Id'])
+    end
+  end
+
+  describe 'UPDATE' do
+    it 'updates a banking alias' do
+      updated_banking_alias = MangoPay::BankingAliases.update(new_banking_alias['Id'] ,{
+          Active: false
+      })
+      expect(updated_banking_alias['Active']).to eq(false)
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches all the banking aliases for a wallet' do
+      bankingaliases = MangoPay::BankingAliases.fetch_for_wallet(new_banking_alias['WalletId'])
+      expect(bankingaliases).to be_kind_of(Array)
+      expect(bankingaliases).not_to be_empty
+    end
+  end
+
+end

data/spec/mangopay/card_registration_spec.rb

@@ -0,0 +1,123 @@
+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['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
+
+      # ...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
+
+    describe '.get_by_fingerprint' do
+      it 'retrieves list of cards having same fingerprint' do
+        completed = new_card_registration_completed
+        card_id = completed['CardId']
+        card = MangoPay::Card.fetch(card_id)
+        fingerprint = card['Fingerprint']
+        result = MangoPay::Card.get_by_fingerprint(fingerprint)
+
+        expect(result).to be_kind_of(Array)
+        result.each do |card|
+          expect(card['Fingerprint']).to eq fingerprint
+        end
+      end
+    end
+  end
+
+  describe 'FETCH Transactions' do
+    it "retrieves list of card's transactions" do
+      card_id = new_card_registration_completed['CardId']
+      transactions = MangoPay::Card.transactions(card_id)
+      expect(transactions).to be_an(Array)
+    end
+  end
+
+  describe 'VALIDATE CARD' do
+    it "validates a card" do
+      created = new_card_registration_completed
+      validated = create_card_validation(created['UserId'], created['CardId'])
+
+      expect(validated).to_not be_nil
+    end
+
+    it "fetches card validation" do
+      created = new_card_registration_completed
+      card_validation = create_card_validation(created['UserId'], created['CardId'])
+      fetched_card_validation = MangoPay::Card.get_card_validation(created['CardId'], card_validation['Id'])
+
+      expect(card_validation['Id']).equal? fetched_card_validation['Id']
+    end
+  end
+
+  describe 'Get transactions by card fingerprint' do
+    it 'retrieves list of transactions for a fingerprint' do
+      completed = new_card_registration_completed
+      card_id = completed['CardId']
+      card = MangoPay::Card.fetch(card_id)
+      fingerprint = card['Fingerprint']
+      result = MangoPay::Card.get_transactions_by_fingerprint(fingerprint)
+
+      expect(result).to be_kind_of(Array)
+      expect(result.count).to be > 0
+    end
+  end
+end

data/spec/mangopay/client_spec.rb

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