mangopay4-ruby-sdk 3.44.0

data/spec/mangopay/payin_swish_web_spec.rb

@@ -0,0 +1,30 @@
+describe MangoPay::PayIn::Swish::Web, type: :feature do
+  include_context 'wallets'
+  include_context 'payins'
+
+  def check_type_and_status(payin)
+    expect(payin['Type']).to eq('PAYIN')
+    expect(payin['Nature']).to eq('REGULAR')
+    expect(payin['PaymentType']).to eq('SWISH')
+    expect(payin['ExecutionType']).to eq('WEB')
+    expect(payin['Status']).to eq('CREATED')
+  end
+
+  describe 'CREATE' do
+    it 'creates a swish web payin' do
+      created = new_payin_swish_web
+      expect(created['Id']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payin' do
+      created = new_payin_swish_web
+      fetched = MangoPay::PayIn.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
+    end
+  end
+end

data/spec/mangopay/payin_twint_web_spec.rb

@@ -0,0 +1,30 @@
+describe MangoPay::PayIn::Twint::Web, type: :feature do
+  include_context 'wallets'
+  include_context 'payins'
+
+  def check_type_and_status(payin)
+    expect(payin['Type']).to eq('PAYIN')
+    expect(payin['Nature']).to eq('REGULAR')
+    expect(payin['PaymentType']).to eq('TWINT')
+    expect(payin['ExecutionType']).to eq('WEB')
+    expect(payin['Status']).to eq('CREATED')
+  end
+
+  describe 'CREATE' do
+    it 'creates a twint web payin' do
+      created = new_payin_twint_web
+      expect(created['Id']).not_to be_nil
+      check_type_and_status(created)
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payin' do
+      created = new_payin_twint_web
+      fetched = MangoPay::PayIn.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
+    end
+  end
+end

data/spec/mangopay/payment_method_metadata_spec.rb

@@ -0,0 +1,15 @@
+describe MangoPay::PaymentMethodMetadata, type: :feature do
+  include_context 'payment_method_metadata'
+
+  describe 'GET PAYMENT METHOD METADATA' do
+    it 'gets a new payment method metadata' do
+      metadata = get_payment_method_metadata
+
+      expect(metadata).not_to be_nil
+      expect(metadata['IssuerCountryCode']).not_to be_nil
+      expect(metadata['IssuingBank']).not_to be_nil
+      expect(metadata['BinData']).not_to be_nil
+      expect(metadata['BinData'][0]['CardType']).not_to be_nil
+    end
+  end
+end

data/spec/mangopay/payout_bankwire_spec.rb

@@ -0,0 +1,93 @@
+describe MangoPay::PayOut::BankWire, type: :feature do
+  include_context 'bank_accounts'
+  include_context 'payins'
+  include_context 'payouts'
+
+  def check_type_and_status(payout, check_status = true)
+    expect(payout['Type']).to eq('PAYOUT')
+    expect(payout['Nature']).to eq('REGULAR')
+    expect(payout['PaymentType']).to eq('BANK_WIRE')
+
+    # linked to correct bank account
+    expect(payout['BankAccountId']).to eq(new_bank_account['Id'])
+
+    if (check_status)
+      # not SUCCEEDED yet: waiting for processing
+      expect(payout['ExecutionDate']).to be_nil
+      expect(payout['Status']).to eq('CREATED')
+      expect(payout['ResultCode']).to be_nil
+      expect(payout['ResultMessage']).to be_nil
+    end
+  end
+
+  describe 'CREATE' do
+
+    it 'creates a bank wire payout' do
+      payin = new_payin_card_direct # this payin is successfull so payout may happen
+      payout = create_new_payout_bankwire(payin)
+      expect(payout['Id']).not_to be_nil
+      check_type_and_status(payout)
+      expect(payout['DebitedWalletId']).to eq(payin['CreditedWalletId'])
+    end
+
+    it 'fails if not enough money' do
+      payin = new_payin_card_web # this payin is NOT processed yet so payout may NOT happen
+      payout = create_new_payout_bankwire(payin, 100)
+      sleep(2)
+      fetched = MangoPay::PayOut::BankWire.get_bankwire(payout['Id'])
+      check_type_and_status(payout, true)
+      expect(fetched['Status']).to eq('FAILED')
+      expect(fetched['ResultCode']).to eq('002998')
+      # expect(fetched['ResultMessage']).to eq('Unsufficient wallet balance')
+    end
+  end
+
+  describe 'Get Bankwire' do
+    it 'gets a bankwire' do
+      created = new_payout_bankwire
+      fetched = MangoPay::PayOut::BankWire.get_bankwire(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      expect(fetched['CreationDate']).to eq(created['CreationDate'])
+    end
+  end
+
+  describe 'Check Eligibility' do
+    it 'checks the eligibility of a payout' do
+      created = new_payout_bankwire
+
+      eligibility = MangoPay::PayOut::InstantPayoutEligibility::Reachability.create(
+        AuthorId: created['AuthorId'],
+        DebitedFunds: {
+          Amount: 10,
+          Currency: 'EUR'
+        },
+        PayoutModeRequested: 'INSTANT_PAYMENT',
+        BankAccountId: created['BankAccountId'],
+        DebitedWalletId: created['DebitedWalletId']
+      )
+
+      expect(created).not_to be_nil
+      expect(eligibility).not_to be_nil
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a payout' do
+      created = new_payout_bankwire
+      fetched = MangoPay::PayOut.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      expect(fetched['CreationDate']).to eq(created['CreationDate'])
+      check_type_and_status(created)
+      check_type_and_status(fetched)
+    end
+  end
+
+  describe 'GET Refunds' do
+    it "fetches the pay-out's refunds" do
+      payout = new_payout_bankwire
+      refunds = MangoPay::PayOut.refunds(payout['Id'])
+      expect(refunds).to be_an(Array)
+    end
+  end
+
+end

data/spec/mangopay/preauthorization_spec.rb

@@ -0,0 +1,51 @@
+describe MangoPay::PreAuthorization do
+  include_context 'users'
+  include_context 'payins'
+
+  describe 'CREATE' do
+    it 'creates a new card pre-authorization' do
+      cardreg = new_card_registration_completed
+      created = new_card_preauthorization
+      expect(created['Id']).not_to be_nil
+      expect(created['CardId']).to eq(cardreg['CardId'])
+      expect(created['AuthorId']).to eq(new_natural_user["Id"])
+      expect(created['PayInId']).to be_nil
+      expect(created['Status']).to eq('SUCCEEDED')
+      expect(created['PaymentStatus']).to eq('WAITING')
+      expect(created['PaymentType']).to eq('CARD')
+      expect(created['ExecutionType']).to eq('DIRECT')
+      # expect(created['Requested3DSVersion']).to eq('V2_1')
+    end
+  end
+
+  describe 'UPDATE' do
+    it 'updates a card pre-authorization' do
+      created = new_card_preauthorization
+      updated = MangoPay::PreAuthorization.update(created['Id'] ,{
+        PaymentStatus: 'CANCELED'
+      })
+      expect(updated['PaymentStatus']).to eq('CANCELED')
+    end
+  end
+
+  describe 'FETCH' do
+    it 'fetches a card pre-authorization' do
+      created = new_card_preauthorization
+      fetched = MangoPay::PreAuthorization.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+      expect(fetched['CardId']).to eq(created['CardId'])
+      expect(fetched['AuthorId']).to eq(created['AuthorId'])
+      expect(fetched['Tag']).to eq(created['Tag'])
+    end
+  end
+
+  describe 'FETCH FOR CARD' do
+    it "fetches a card's pre-authorizations" do
+      created = new_card_preauthorization
+      fetched = MangoPay::Card.get_pre_authorizations(created['CardId'])
+
+      expect(fetched).to be_an(Array)
+    end
+  end
+
+end

data/spec/mangopay/recipient_spec.rb

@@ -0,0 +1,134 @@
+describe MangoPay::Recipient do
+  include_context 'recipient'
+
+  describe 'CREATE' do
+    it 'creates a new recipient' do
+      recipient = new_recipient
+      assert_recipient(recipient)
+      expect(recipient['Status']).to eq('PENDING')
+    end
+  end
+
+  describe 'GET' do
+    it 'fetches a recipient' do
+      recipient = new_recipient
+      fetched = MangoPay::Recipient.get(recipient['Id'])
+      assert_recipient(fetched)
+    end
+  end
+
+  describe 'GET User Recipients' do
+    it 'fetches recipients without query param' do
+      john = create_new_natural_user_sca_owner
+      create_new_recipient(john['Id'])
+      fetched = MangoPay::Recipient.get_user_recipients(john['Id'])
+      expect(fetched).not_to be_nil
+      expect(fetched).to be_kind_of(Array)
+      expect(fetched).not_to be_empty
+    end
+
+    it 'fetches recipients with scope PAYOUT' do
+      john = create_new_natural_user_sca_owner
+      create_new_recipient(john['Id'])
+      fetched = MangoPay::Recipient.get_user_recipients(john['Id'], {RecipientScope: "PAYOUT"})
+      expect(fetched).not_to be_nil
+      expect(fetched).to be_kind_of(Array)
+      expect(fetched).not_to be_empty
+    end
+
+    it 'fetches recipients with scope PAYIN' do
+      john = create_new_natural_user_sca_owner
+      create_new_recipient(john['Id'])
+      fetched = MangoPay::Recipient.get_user_recipients(john['Id'], {RecipientScope: "PAYIN"})
+      expect(fetched).not_to be_nil
+      expect(fetched).to be_kind_of(Array)
+      expect(fetched).to be_empty
+    end
+  end
+
+  describe 'GET Schema' do
+    it 'fetches schema for LocalBankTransfer, Individual' do
+      schema = MangoPay::Recipient.get_schema('LocalBankTransfer', 'Individual', 'GBP', 'GB')
+      expect(schema).not_to be_nil
+      expect(schema['DisplayName']).not_to be_nil
+      expect(schema['Currency']).not_to be_nil
+      expect(schema['RecipientType']).not_to be_nil
+      expect(schema['PayoutMethodType']).not_to be_nil
+      expect(schema['RecipientScope']).not_to be_nil
+      expect(schema['Tag']).not_to be_nil
+      expect(schema['IndividualRecipient']).not_to be_nil
+      expect(schema['LocalBankTransfer']).not_to be_nil
+      expect(schema['BusinessRecipient']).to be_nil
+      expect(schema['InternationalBankTransfer']).to be_nil
+      expect(schema['Country']).not_to be_nil
+    end
+
+    it 'fetches schema for InternationalBankTransfer, Business' do
+      schema = MangoPay::Recipient.get_schema('InternationalBankTransfer', 'Business', 'GBP', 'GB')
+      expect(schema).not_to be_nil
+      expect(schema['DisplayName']).not_to be_nil
+      expect(schema['Currency']).not_to be_nil
+      expect(schema['RecipientType']).not_to be_nil
+      expect(schema['PayoutMethodType']).not_to be_nil
+      expect(schema['RecipientScope']).not_to be_nil
+      expect(schema['Tag']).not_to be_nil
+      expect(schema['BusinessRecipient']).not_to be_nil
+      expect(schema['InternationalBankTransfer']).not_to be_nil
+      expect(schema['IndividualRecipient']).to be_nil
+      expect(schema['LocalBankTransfer']).to be_nil
+      expect(schema['Country']).not_to be_nil
+    end
+  end
+
+  describe 'GET Payout Methods' do
+    it 'fetches payout methods' do
+      payout_methods = MangoPay::Recipient.get_payout_methods('DE', 'EUR')
+      expect(payout_methods).not_to be_nil
+      expect(payout_methods['AvailablePayoutMethods']).to be_kind_of(Array)
+      expect(payout_methods['AvailablePayoutMethods']).not_to be_empty
+    end
+  end
+
+  describe 'VALIDATE' do
+    it 'validates a recipient' do
+      recipient = define_new_recipient
+      john = create_new_natural_user_sca_owner
+      # it should pass
+      MangoPay::Recipient.validate(recipient, john['Id'])
+
+      # it should throw error
+      recipient['Currency'] = nil
+      expect { MangoPay::Recipient.validate(recipient, john['Id']) }.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 'DEACTIVATE' do
+    it 'deactivates a recipient' do
+      pending("a recipient needs to be manually activated before running the test")
+      john = create_new_natural_user_sca_owner
+      recipient = create_new_recipient(john['Id'])
+      deactivated = MangoPay::Recipient.deactivate(recipient['Id'])
+      fetched = MangoPay::Recipient.get(recipient['Id'])
+      expect(deactivated['Status']).to eq('DEACTIVATED')
+      expect(fetched['Status']).to eq('DEACTIVATED')
+    end
+  end
+end
+
+
+def assert_recipient(recipient)
+  expect(recipient).not_to be_nil
+  expect(recipient['Status']).not_to be_nil
+  expect(recipient['DisplayName']).not_to be_nil
+  expect(recipient['PayoutMethodType']).not_to be_nil
+  expect(recipient['RecipientType']).not_to be_nil
+  expect(recipient['IndividualRecipient']).not_to be_nil
+  expect(recipient['LocalBankTransfer']).not_to be_nil
+  expect(recipient['RecipientScope']).not_to be_nil
+  expect(recipient['UserId']).not_to be_nil
+  expect(recipient['Country']).not_to be_nil
+end

data/spec/mangopay/recurring_payin_spec.rb

@@ -0,0 +1,222 @@
+describe MangoPay::PayIn::RecurringPayments, type: :feature do
+  include_context 'wallets'
+  include_context 'users'
+  include_context 'payins'
+
+  describe 'CREATE' do
+    it 'creates a recurring payment' do
+      cardreg = new_card_registration_completed
+      wallet = new_wallet
+      recurring = MangoPay::PayIn::RecurringPayments::Recurring.create(
+        AuthorId: new_natural_user['Id'],
+        CardId: cardreg['CardId'],
+        CreditedUserId: wallet['Owners'][0],
+        CreditedWalletId: wallet['Id'],
+        FirstTransactionDebitedFunds: {Currency: 'EUR', Amount: 10},
+        FirstTransactionFees: {Currency: 'EUR', Amount: 1},
+        Billing: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        Shipping: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        FreeCycles: 0
+      )
+      expect(recurring).not_to be_nil
+      expect(recurring['Status']).not_to be_nil
+      expect(recurring['Id']).not_to be_nil
+      expect(recurring['FreeCycles']).not_to be_nil
+
+      id = recurring['Id']
+
+      get = MangoPay::PayIn::RecurringPayments::Recurring.fetch(id)
+      expect(get).not_to be_nil
+      expect(get['FreeCycles']).not_to be_nil
+
+      cit = MangoPay::PayIn::RecurringPayments::CIT.create(
+        RecurringPayinRegistrationId: recurring['Id'],
+        IpAddress: "2001:0620:0000:0000:0211:24FF:FE80:C12C",
+        SecureModeReturnURL: "http://www.my-site.com/returnurl",
+        StatementDescriptor: "lorem",
+        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"
+        }
+      )
+
+      expect(cit).not_to be_nil
+
+      update = MangoPay::PayIn::RecurringPayments::Recurring.update(id, {
+        Status: 'ENDED'
+      })
+
+      expect(update).not_to be_nil
+    end
+
+    it 'creates a recurring paypal payment CIT' do
+      wallet = new_wallet
+      recurring = MangoPay::PayIn::RecurringPayments::Recurring.create(
+        AuthorId: new_natural_user['Id'],
+        CreditedUserId: wallet['Owners'][0],
+        CreditedWalletId: wallet['Id'],
+        FirstTransactionDebitedFunds: {Currency: 'EUR', Amount: 1000},
+        FirstTransactionFees: {Currency: 'EUR', Amount: 0},
+        Billing: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        Shipping: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        PaymentType: 'PAYPAL'
+      )
+      expect(recurring).not_to be_nil
+      expect(recurring['Status']).not_to be_nil
+      expect(recurring['Id']).not_to be_nil
+
+      cit = MangoPay::PayIn::RecurringPayments::PayPalCIT.create(
+        {
+          "ReturnURL": "http://example.com",
+          "CancelURL": "http://example.net",
+          "LineItems": [
+            {
+              "Name": "Running shoes",
+              "Quantity": 1,
+              "UnitAmount": 1000,
+              "TaxAmount": 0,
+              "Description": "ID of Seller 1",
+              "Category": "PHYSICAL_GOODS"
+            }
+          ],
+          "Tag": "Created using the Mangopay API Postman collection",
+          "RecurringPayinRegistrationId": recurring['Id'],
+          "ShippingPreference": "SET_PROVIDED_ADDRESS",
+          "Reference": "abcd-efgh-ijkl",
+          "StatementDescriptor": "Example123"
+        }
+      )
+
+      expect(cit).not_to be_nil
+      # expect(cit['Status']).to eq('CREATED')
+      expect(cit['PaymentType']).to eq('PAYPAL')
+      expect(cit['ExecutionType']).to eq('WEB')
+    end
+
+    it 'creates a recurring paypal payment MIT' do
+      wallet = new_wallet
+      recurring = MangoPay::PayIn::RecurringPayments::Recurring.create(
+        AuthorId: new_natural_user['Id'],
+        CreditedUserId: wallet['Owners'][0],
+        CreditedWalletId: wallet['Id'],
+        FirstTransactionDebitedFunds: {Currency: 'EUR', Amount: 1000},
+        FirstTransactionFees: {Currency: 'EUR', Amount: 0},
+        Billing: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        Shipping: {
+          Address: {
+            AddressLine1: 'AddressLine1',
+            AddressLine2: 'AddressLine2',
+            City: 'City',
+            Region: 'Region',
+            PostalCode: 'PostalCode',
+            Country: 'FR'
+          },
+          FirstName: 'Joe',
+          LastName: 'Blogs'
+        },
+        PaymentType: 'PAYPAL'
+      )
+      expect(recurring).not_to be_nil
+      expect(recurring['Status']).not_to be_nil
+      expect(recurring['Id']).not_to be_nil
+
+      cit = MangoPay::PayIn::RecurringPayments::PayPalMIT.create(
+        {
+          "ReturnURL": "http://example.com",
+          "CancelURL": "http://example.net",
+          "LineItems": [
+            {
+              "Name": "Running shoes",
+              "Quantity": 1,
+              "UnitAmount": 1000,
+              "TaxAmount": 0,
+              "Description": "ID of Seller 1",
+              "Category": "PHYSICAL_GOODS"
+            }
+          ],
+          "Tag": "Created using the Mangopay API Postman collection",
+          "RecurringPayinRegistrationId": recurring['Id'],
+          "ShippingPreference": "SET_PROVIDED_ADDRESS",
+          "Reference": "abcd-efgh-ijkl",
+          "StatementDescriptor": "Example123",
+          "DebitedFunds": {
+            "Currency": "EUR",
+            "Amount": 1000
+          },
+          "Fees": {
+            "Currency": "EUR",
+            "Amount": 0
+          }
+        }
+      )
+
+      expect(cit).not_to be_nil
+      # expect(cit['Status']).to eq('CREATED')
+      expect(cit['PaymentType']).to eq('PAYPAL')
+      expect(cit['ExecutionType']).to eq('WEB')
+    end
+  end
+end

data/spec/mangopay/refund_spec.rb

@@ -0,0 +1,34 @@
+describe MangoPay::Refund do
+  include_context 'transfers'
+
+  describe 'FETCH' do
+    it 'fetches a refund' do
+      transfer = new_transfer
+      resource = MangoPay::Transfer.refund(transfer['Id'], { AuthorId: transfer['AuthorId'] })
+
+      refund = MangoPay::Refund.fetch(resource['Id'])
+
+      expect(refund['Id']).not_to be_nil
+      expect(refund['Status']).to eq('SUCCEEDED')
+      expect(refund['Type']).to eq('TRANSFER')
+      expect(refund['Nature']).to eq('REFUND')
+      expect(refund['InitialTransactionType']).to eq('TRANSFER')
+      expect(refund['InitialTransactionId']).to eq(transfer['Id'])
+      expect(refund['DebitedWalletId']).to eq(transfer['CreditedWalletId'])
+      expect(refund['CreditedWalletId']).to eq(transfer['DebitedWalletId'])
+    end
+  end
+
+  #describe 'FETCH for Repudiation' do
+  #  it "fetches a repudiation's refunds" do
+  #    disputes = MangoPay::Dispute.fetch
+  #   dispute = disputes.find do |dispute|
+  #      dispute['DisputeType'] == 'NOT_CONTESTABLE'\
+  #         && !dispute['InitialTransactionId'].nil?
+  #   end
+  #    repudiation_id = MangoPay::Dispute.transactions(dispute['Id'])[0]['Id']
+  #    refunds = MangoPay::Refund.of_repudiation(repudiation_id)
+  #    expect(refunds).to be_an(Array)
+  #  end
+  # end
+end

data/spec/mangopay/regulatory_spec.rb

@@ -0,0 +1,26 @@
+describe MangoPay::Regulatory do
+
+  describe 'GET Country Authorizations' do
+    it 'can get country authorizations' do
+      country_authorizations = MangoPay::Regulatory.get_country_authorizations('FR')
+
+      expect(country_authorizations).not_to be_nil
+      expect(country_authorizations['CountryCode']).not_to be_nil
+      expect(country_authorizations['CountryName']).not_to be_nil
+      expect(country_authorizations['Authorization']).not_to be_nil
+      expect(country_authorizations['LastUpdate']).not_to be_nil
+    end
+  end
+
+  describe 'GET All Countries Authorizations' do
+    it 'can get all countries authorizations' do
+      country_authorizations = MangoPay::Regulatory.get_all_countries_authorizations
+
+      expect(country_authorizations).not_to be_nil
+      expect(country_authorizations[0]['CountryCode']).not_to be_nil
+      expect(country_authorizations[0]['CountryName']).not_to be_nil
+      expect(country_authorizations[0]['Authorization']).not_to be_nil
+      expect(country_authorizations[0]['LastUpdate']).not_to be_nil
+    end
+  end
+end

data/spec/mangopay/report_spec.rb

@@ -0,0 +1,40 @@
+describe MangoPay::Report do
+
+  def create
+    params = {
+      Tag: 'custom meta',
+      CallbackURL: 'http://www.my-site.com/callbackURL/',
+      DownloadFormat: 'CSV',
+      Sort: 'CreationDate:DESC',
+      Preview: false,
+      Filters: {},
+      Columns: [ 'Id', 'CreationDate' ],
+      ReportType: 'transactions'
+    }
+    MangoPay::Report.create(params)
+  end
+
+  describe 'CREATE' do
+    it 'creates a report' do
+      created = create
+      expect(created['Id']).to_not be_nil
+    end
+  end
+
+  describe 'FETCH' do
+
+    it 'fetches a report' do
+      created = create
+      fetched = MangoPay::Report.fetch(created['Id'])
+      expect(fetched['Id']).to eq(created['Id'])
+    end
+
+    it 'fetches all the reports' do
+      reports = MangoPay::Report.fetch()
+      expect(reports).to be_kind_of(Array)
+      expect(reports).not_to be_empty
+    end
+
+  end
+
+end