mangopay4-ruby-sdk 3.51.0 → 4.0.0

data/spec/mangopay/acquiring_spec.rb

@@ -1,202 +0,0 @@
-xdescribe MangoPay::Acquiring do
-  include_context 'wallets'
-  include_context 'payins'
-
-  let(:card_id) { 'placeholder' }
-  let(:author_id) { 'placeholder' }
-
-  describe 'PAY_IN CARD DIRECT' do
-    it 'creates a Card Direct PayIn' do
-      created = create_new_pay_in_card_direct
-
-      assert_common_pay_in_properties(created)
-      expect(created['PaymentType']).to eq('CARD')
-      expect(created['ExecutionType']).to eq('DIRECT')
-    end
-  end
-
-  describe 'REFUND' do
-    it 'creates a Refund for a PayIn' do
-      pay_in = create_new_pay_in_card_direct
-      refund = MangoPay::Acquiring::Refund.create(pay_in['Id'], { DebitedFunds: { Currency: 'EUR', Amount: 10 } })
-
-      expect(refund['Id']).not_to be_nil
-      expect(refund['Status']).to eq('SUCCEEDED')
-      expect(refund['Type']).to eq('PAYOUT')
-      expect(refund['Nature']).to eq('REFUND')
-      expect(refund['InitialTransactionType']).to eq('PAYIN')
-      expect(refund['InitialTransactionId']).to eq(pay_in['Id'])
-    end
-  end
-
-  describe 'PAY_IN APPLE_PAY' do
-    it 'creates an ApplePay direct PayIn' do
-      created = MangoPay::Acquiring::PayIn::ApplePay::Direct.create(
-        DebitedFunds: { Currency: 'EUR', Amount: 100 },
-        PaymentData: {
-          transactionId: "97e64d87f13a89ff6443cdcc205d5ccf7e15368b0d64126a8a2e0888a3a5c2a0",
-          network: "MasterCard",
-          tokenDataø: "{\"data\":\"2TihgKbmyPje02.........wAAAAAAAA==\",\"header\":{\"publicKeyHash\":\"xUyeFb75d359bfPEiq2JJMQj694UAxtTuBsaTWMOJxQ=\",\"ephemeralPublicKey\":\"MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEkeuICjZ7x15b7hPEBEBT5Zp43l95wCmJCU3QNxBvOCusG9w9sJMULuXlT4K8LOlPgaZzAcyWlfNwnLivVdOPfg==\",\"transactionId\":\"97e64d87f13a89ff6443cdcc205d5ccf7e15368b0d64126a8a2e0888a3a5c2a0\"},\"version\":\"EC_v1\"}"
-        }
-      )
-
-      assert_common_pay_in_properties(created)
-      expect(created['PaymentType']).to eq('APPLEPAY')
-      expect(created['ExecutionType']).to eq('DIRECT')
-    end
-  end
-
-  describe 'PAY_IN GOOGLE_PAY' do
-    it 'creates a GooglePay direct PayIn' do
-      created = MangoPay::Acquiring::PayIn::GooglePay::Direct.create(
-        DebitedFunds: { Currency: 'EUR', Amount: 199 },
-        IpAddress: "2001:0620:0000:0000:0211:24FF:FE80:C12C",
-        SecureModeReturnURL: 'http://test.com',
-        BrowserInfo: {
-          AcceptHeader: "text/html, application/xhtml+xml, application/xml;q=0.9, /;q=0.8",
-          JavaEnabled: true,
-          Language: "fr-FR",
-          ColorDepth: 4,
-          ScreenHeight: 1800,
-          ScreenWidth: 400,
-          JavascriptEnabled: true,
-          TimeZoneOffset: "+60",
-          UserAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 13_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148"
-        },
-        PaymentData: "{\"signature\":\"MEUCIQDc49/Bw1lTk8ok2fUe4UT......................\\u003d\\\"}\"}"
-      )
-
-      assert_common_pay_in_properties(created)
-      expect(created['PaymentType']).to eq('GOOGLEPAY')
-      expect(created['ExecutionType']).to eq('DIRECT')
-    end
-  end
-
-  describe 'PAY_IN IDEAL WEB' do
-    it 'creates an Ideal Web PayIn' do
-      created = MangoPay::Acquiring::PayIn::Ideal::Web.create(
-        DebitedFunds: { Currency: 'EUR', Amount: 100 },
-        ReturnURL: 'http://www.my-site.com/returnURL'
-      )
-
-      assert_common_pay_in_properties(created)
-      expect(created['PaymentType']).to eq('IDEAL')
-      expect(created['ExecutionType']).to eq('WEB')
-    end
-  end
-
-  describe 'PAY_IN PAYPAL' do
-    it 'creates a PayPal Web PayIn' do
-      created = MangoPay::Acquiring::PayIn::PayPal::Web.create(
-        DebitedFunds: { Currency: 'EUR', Amount: 400 },
-        ReturnUrl: "http://example.com",
-        LineItems: [
-          {
-            Name: "running shoes",
-            Quantity: 1,
-            UnitAmount: 200,
-            TaxAmount: 0,
-            Description: "seller1 ID"
-          },
-          {
-            Name: "running shoes",
-            Quantity: 1,
-            UnitAmount: 200,
-            TaxAmount: 0,
-            Description: "seller2 ID"
-          }
-        ]
-      )
-
-      assert_common_pay_in_properties(created)
-      expect(created['PaymentType']).to eq('PAYPAL')
-      expect(created['ExecutionType']).to eq('WEB')
-    end
-
-    it 'creates PayPal DataCollection' do
-      data_collection = MangoPay::Acquiring::PayIn::PayPal::Web.create_data_collection(
-        {
-          "sender_account_id": "A12345N343",
-          "sender_first_name": "Jane",
-          "sender_last_name": "Doe",
-          "sender_email": "jane.doe@sample.com",
-          "sender_phone": "(042)11234567",
-          "sender_address_zip": "75009",
-          "sender_country_code": "FR",
-          "sender_create_date": "2012-12-09T19:14:55.277-0:00",
-          "sender_signup_ip": "10.220.90.20",
-          "sender_popularity_score": "high",
-          "receiver_account_id": "A12345N344",
-          "receiver_create_date": "2012-12-09T19:14:55.277-0:00",
-          "receiver_email": "jane@sample.com",
-          "receiver_address_country_code": "FR",
-          "business_name": "Jane Ltd",
-          "recipient_popularity_score": "high",
-          "first_interaction_date": "2012-12-09T19:14:55.277-0:00",
-          "txn_count_total": "34",
-          "vertical": "Household goods",
-          "transaction_is_tangible": "0"
-        }
-      )
-      expect(data_collection['dataCollectionId']).not_to be_nil
-    end
-  end
-
-  describe 'CARD VALIDATION' do
-    it 'creates card validation' do
-      params = {
-        AuthorId: author_id,
-        SecureModeReturnURL: "https://mangopay.com",
-        IpAddress: "2001:0620:0000:0000:0211:24FF:FE80:C12C",
-        Tag: "custom meta",
-        BrowserInfo: {
-          AcceptHeader: "text/html, application/xhtml+xml, application/xml;q=0.9, /;q=0.8",
-          JavaEnabled: true,
-          Language: "FR-FR",
-          ColorDepth: 4,
-          ScreenHeight: 1800,
-          ScreenWidth: 400,
-          JavascriptEnabled: true,
-          TimeZoneOffset: "+60",
-          UserAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 13_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148"
-        }
-      }
-      card_validation = MangoPay::Acquiring::PayIn::Card.create_card_validation(card_id, params)
-      expect(card_validation).not_to be_nil
-      expect("SUCCEEDED").to eq(card_validation['Status'])
-    end
-  end
-
-  def create_new_pay_in_card_direct
-    MangoPay::Acquiring::PayIn::Card::Direct.create(
-      DebitedFunds: { Currency: 'EUR', Amount: 100 },
-      CardType: 'CB_VISA_MASTERCARD',
-      CardId: card_id,
-      SecureMode: 'DEFAULT',
-      SecureModeReturnURL: 'http://test.com',
-      Tag: 'Acquiring Test PayIn/Card/Direct',
-      BrowserInfo: {
-        AcceptHeader: "text/html, application/xhtml+xml, application/xml;q=0.9, /;q=0.8",
-        JavaEnabled: true,
-        Language: "FR-FR",
-        ColorDepth: 4,
-        ScreenHeight: 1800,
-        ScreenWidth: 400,
-        JavascriptEnabled: true,
-        TimeZoneOffset: "+60",
-        UserAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 13_6_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148"
-      },
-      IpAddress: "2001:0620:0000:0000:0211:24FF:FE80:C12C"
-    )
-  end
-
-  def assert_common_pay_in_properties(pay_in)
-    expect(pay_in['Id']).not_to be_nil
-    expect(pay_in['Type']).to eq('PAYIN')
-    expect(pay_in['Nature']).to eq('REGULAR')
-    expect(pay_in['Status']).to eq('SUCCEEDED')
-    expect(pay_in['ResultCode']).to eq('000000')
-    expect(pay_in['ResultMessage']).to eq('Success')
-    expect(pay_in['ExecutionDate']).to be > 0
-  end
-end

data/spec/mangopay/authorization_token_spec.rb

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

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

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

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