mangopay4-ruby-sdk 3.52.0 → 4.0.0

data/spec/mangopay/recurring_payin_spec.rb

@@ -1,557 +0,0 @@
-describe MangoPay::PayIn::RecurringPayments, type: :feature do
-  include_context 'wallets'
-  include_context 'users'
-  include_context 'payins'
-
-  describe 'CREATE' do
-    def create_card_pay_in_registration
-      card_registration = new_card_registration_completed
-      wallet = new_wallet
-      MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.create(
-        AuthorId: new_natural_user['Id'],
-        CardId: card_registration['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
-      )
-    end
-
-    def create_paypal_pay_in_registration
-      wallet = new_wallet
-      MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.create(
-        AuthorId: new_natural_user['Id'],
-        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'
-        },
-        FreeCycles: 0,
-        PaymentType: 'PAYPAL'
-      )
-    end
-
-    def create_apple_pay_pay_in_registration
-      wallet = new_wallet
-      MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.create(
-        AuthorId: new_natural_user['Id'],
-        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,
-        PaymentData: {
-          TokenData: 'placeholder',
-          Network: 'placeholder',
-          TransactionId: 'placeholder'
-        },
-        PaymentType: 'APPLEPAY'
-      )
-    end
-
-    def create_google_pay_pay_in_registration
-      wallet = new_wallet
-      MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.create(
-        AuthorId: new_natural_user['Id'],
-        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,
-        PaymentData: 'placeholder',
-        PaymentType: 'GOOGLEPAY'
-      )
-    end
-
-    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 'handles a card pay in registration' do
-      pay_in_registration = create_card_pay_in_registration
-
-      expect(pay_in_registration).not_to be_nil
-      expect(pay_in_registration['Status']).not_to be_nil
-      expect(pay_in_registration['Id']).not_to be_nil
-      expect(pay_in_registration['FreeCycles']).not_to be_nil
-      expect(pay_in_registration['PaymentType']).to eq('CARD_DIRECT')
-
-      get = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.fetch(pay_in_registration['Id'])
-      expect(get).not_to be_nil
-      expect(get['Status']).not_to be_nil
-
-      update = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.update(pay_in_registration['Id'], {
-        Status: 'ENDED'
-      })
-
-      expect(update).not_to be_nil
-      expect(update['Status']).to eq('ENDED')
-    end
-
-    it 'handles a PayPal pay in registration' do
-      pay_in_registration = create_paypal_pay_in_registration
-
-      expect(pay_in_registration).not_to be_nil
-      expect(pay_in_registration['Status']).not_to be_nil
-      expect(pay_in_registration['Id']).not_to be_nil
-      expect(pay_in_registration['FreeCycles']).not_to be_nil
-      expect(pay_in_registration['PaymentType']).to eq('PAYPAL')
-
-      get = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.fetch(pay_in_registration['Id'])
-      expect(get).not_to be_nil
-      expect(get['Status']).not_to be_nil
-
-      update = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.update(pay_in_registration['Id'], {
-        Status: 'ENDED'
-      })
-
-      expect(update).not_to be_nil
-      expect(update['Status']).to eq('ENDED')
-    end
-
-    xit 'handles a ApplePay pay in registration' do
-      pay_in_registration = create_apple_pay_pay_in_registration
-
-      expect(pay_in_registration).not_to be_nil
-      expect(pay_in_registration['Status']).not_to be_nil
-      expect(pay_in_registration['Id']).not_to be_nil
-      expect(pay_in_registration['FreeCycles']).not_to be_nil
-      expect(pay_in_registration['PaymentType']).to eq('APPLEPAY')
-
-      get = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.fetch(pay_in_registration['Id'])
-      expect(get).not_to be_nil
-      expect(get['Status']).not_to be_nil
-
-      update = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.update(pay_in_registration['Id'], {
-        Status: 'ENDED'
-      })
-
-      expect(update).not_to be_nil
-      expect(update['Status']).to eq('ENDED')
-    end
-
-    xit 'handles a GooglePay pay in registration' do
-      pay_in_registration = create_google_pay_pay_in_registration
-
-      expect(pay_in_registration).not_to be_nil
-      expect(pay_in_registration['Status']).not_to be_nil
-      expect(pay_in_registration['Id']).not_to be_nil
-      expect(pay_in_registration['FreeCycles']).not_to be_nil
-      expect(pay_in_registration['PaymentType']).to eq('GOOGLEPAY')
-
-      get = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.fetch(pay_in_registration['Id'])
-      expect(get).not_to be_nil
-      expect(get['Status']).not_to be_nil
-
-      update = MangoPay::PayIn::RecurringPayments::RecurringPayInRegistration.update(pay_in_registration['Id'], {
-        Status: 'ENDED'
-      })
-
-      expect(update).not_to be_nil
-      expect(update['Status']).to eq('ENDED')
-    end
-
-    it 'creates recurring card payins' do
-      pay_in_registration = create_card_pay_in_registration
-
-      recurring_card_pay_in_cit = MangoPay::PayIn::RecurringPayments::RecurringCardPayIn.create(
-        RecurringPayinRegistrationId: pay_in_registration['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(recurring_card_pay_in_cit).not_to be_nil
-      expect(recurring_card_pay_in_cit['Status']).not_to be_nil
-
-      recurring_card_pay_in_mit = MangoPay::PayIn::RecurringPayments::RecurringCardPayIn.create(
-        RecurringPayinRegistrationId: pay_in_registration['Id'],
-        DebitedFunds: { Currency: 'EUR', Amount: 100 },
-        Fees: { Currency: 'EUR', Amount: 10 },
-      )
-      expect(recurring_card_pay_in_mit).not_to be_nil
-      expect(recurring_card_pay_in_mit['Status']).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
-
-    it 'creates recurring PayPal payins' do
-      pay_in_registration = create_paypal_pay_in_registration
-
-      recurring_paypal_pay_in_cit = MangoPay::PayIn::RecurringPayments::RecurringPayPalPayIn.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": pay_in_registration['Id'],
-          "ShippingPreference": "SET_PROVIDED_ADDRESS",
-          "Reference": "abcd-efgh-ijkl",
-          "StatementDescriptor": "Example123"
-        }
-      )
-
-      expect(recurring_paypal_pay_in_cit).not_to be_nil
-      expect(recurring_paypal_pay_in_cit['Status']).to eq('CREATED')
-      expect(recurring_paypal_pay_in_cit['PaymentType']).to eq('PAYPAL')
-
-      recurring_paypal_pay_in_mit = MangoPay::PayIn::RecurringPayments::RecurringPayPalPayIn.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": pay_in_registration['Id'],
-          "ShippingPreference": "SET_PROVIDED_ADDRESS",
-          "Reference": "abcd-efgh-ijkl",
-          "StatementDescriptor": "Example123",
-          "DebitedFunds": {
-            "Currency": "EUR",
-            "Amount": 1000
-          },
-          "Fees": {
-            "Currency": "EUR",
-            "Amount": 0
-          }
-        }
-        )
-      expect(recurring_paypal_pay_in_mit).not_to be_nil
-      expect(recurring_paypal_pay_in_mit['Status']).to eq('CREATED')
-      expect(recurring_paypal_pay_in_mit['PaymentType']).to eq('PAYPAL')
-    end
-  end
-end

data/spec/mangopay/refund_spec.rb

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

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

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