trolley 1.0.3 → 1.1.0

data/test/integration/InvoiceTest.rb

@@ -0,0 +1,156 @@
+require_relative '../test_helper'
+
+class InvoiceTest < Test::Unit::TestCase
+  include TestHelper
+
+  def create_recipient
+    uuid = SecureRandom.uuid.to_s
+    recipient = @client.recipient.create(
+      type: 'individual',
+      firstName: 'Tom',
+      lastName: 'Jones',
+      email: "test.batch#{uuid}@example.com",
+      address: {
+        street1: '123 Wolfstrasse',
+        city: 'Berlin',
+        country: 'DE',
+        postalCode: '123123'
+      }
+    )
+    @client.recipient_account.create(recipient.id, type: 'bank-transfer', currency: 'EUR', country: 'DE', iban: 'DE89 3704 0044 0532 0130 00')
+    recipient
+  end
+
+  def test_find
+    with_vcr do
+      recipient = create_recipient
+      invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+      find = @client.invoice.find(invoiceId: invoice.id)
+      assert_not_nil(find)
+    end
+  end
+
+  def test_search
+    with_vcr do
+      recipient = create_recipient
+      @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+      search = @client.invoice.search({})
+      assert_true(search.count.positive?)
+    end
+  end
+
+  def test_create
+    with_vcr do
+      recipient = create_recipient
+      invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+      assert_not_nil(invoice)
+      assert_not_nil(invoice.id)
+
+      invoice = @client.invoice.search({})
+      assert_true(invoice.count.positive?)
+    end
+  end
+
+  def test_create_line
+    with_vcr do
+      recipient = create_recipient
+      invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+      assert_not_nil(invoice)
+      assert_not_nil(invoice.id)
+      assert_equal([], invoice.lines)
+
+      invoice_line = @client.invoice.create_line(invoiceId: invoice.id, lines: [{ unitAmount: { value: '2000', currency: 'USD' } }])
+      assert_not_nil(invoice_line.lines)
+      assert_not_nil(invoice_line.lines.first['id'])
+
+      findInvoice = @client.invoice.find(invoiceId: invoice.id)
+      assert_true(findInvoice.lines.count.positive?)
+    end
+  end
+
+  def test_update
+    with_vcr do
+      recipient = create_recipient
+      invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+      assert_not_nil(invoice)
+      assert_not_nil(invoice.id)
+
+      invoices = @client.invoice.search({})
+      assert_true(invoices.count.positive?)
+
+      response = @client.invoice.update(invoiceId: invoice.id, description: 'Integration Test Invoice Update')
+      assert_true(response)
+      findInvoice = @client.invoice.find(invoiceId: invoice.id)
+      assert_equal('Integration Test Invoice Update', findInvoice.description)
+      assert_equal('open', findInvoice.status)
+    end
+  end
+
+  def test_update_line
+    with_vcr do
+      recipient = create_recipient
+      invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+      assert_not_nil(invoice)
+      assert_not_nil(invoice.id)
+      assert_equal([], invoice.lines)
+
+      invoice_line = @client.invoice.create_line(invoiceId: invoice.id, lines: [{ unitAmount: { value: '2000', currency: 'USD' } }])
+      assert_not_nil(invoice_line.lines)
+      assert_not_nil(invoice_line.lines.first['id'])
+
+      response = @client.invoice.update_line(
+        invoiceId: invoice.id,
+        lines: [{
+          invoiceLineId: invoice_line.lines.first['id'],
+          unitAmount: { value: '3000', currency: 'USD' }
+        }]
+      )
+      assert_true(response)
+
+      findInvoice = @client.invoice.find(invoiceId: invoice.id)
+      assert_equal('3000.00', findInvoice.lines.first['unitAmount']['value'])
+    end
+  end
+
+  def test_delete
+    with_vcr do
+      recipient = create_recipient
+      invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+      assert_not_nil(invoice)
+      assert_not_nil(invoice.id)
+
+      invoices = @client.invoice.search({})
+      assert_true(invoices.count.positive?)
+
+      response = @client.invoice.delete(invoiceIds: invoices.map(&:id))
+      assert_true(response)
+    end
+  end
+
+  def test_delete_line
+    with_vcr do
+      recipient = create_recipient
+      invoice = @client.invoice.create(recipientId: recipient.id, description: 'Integration Test Invoice Create')
+      assert_not_nil(invoice)
+      assert_not_nil(invoice.id)
+      assert_equal([], invoice.lines)
+
+      invoice_line = @client.invoice.create_line(invoiceId: invoice.id, lines: [{ unitAmount: { value: '2000', currency: 'USD' } }])
+
+      response = @client.invoice.delete_line(invoiceId: invoice.id, invoiceLineIds: [invoice_line.lines.first['id']])
+      assert_true(response)
+    end
+  end
+
+  def test_support_error_arrays
+    with_vcr do
+      @client.invoice.create(recipientId: 'invalid', description: 'Integration Test Invoice Create')
+    rescue ::Trolley::TrolleyError => e
+      assert_equal(1, e.validation_errors.count)
+      assert_equal('recipientId', e.validation_errors.first['field'])
+      assert_equal('Value is invalid', e.validation_errors.first['message'])
+      assert_equal('invalid_field', e.validation_errors.first['code'])
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength

data/test/integration/OfflinePaymentTest.rb

@@ -0,0 +1,109 @@
+require_relative '../test_helper'
+
+class OfflinePaymentTest < Test::Unit::TestCase
+  include TestHelper
+
+  def create_recipient
+    uuid = SecureRandom.uuid.to_s
+    recipient = @client.recipient.create(
+      type: 'individual',
+      firstName: 'Tom',
+      lastName: 'Jones',
+      email: "test.batch#{uuid}@example.com",
+      address: {
+        street1: '123 Wolfstrasse',
+        city: 'Berlin',
+        country: 'DE',
+        postalCode: '123123'
+      }
+    )
+    @client.recipient_account.create(recipient.id, type: 'bank-transfer', currency: 'EUR', country: 'DE', iban: 'DE89 3704 0044 0532 0130 00')
+    recipient
+  end
+
+  def test_create
+    with_vcr do
+      recipient = create_recipient
+      offline_payment = @client.offline_payment.create(
+        recipient.id,
+        {
+          amount: '10.00',
+          currency: 'EUR'
+        }
+      )
+
+      assert_not_nil(offline_payment)
+      assert_not_nil(offline_payment.id)
+      assert_equal('10.00', offline_payment.amount)
+      assert_equal('EUR', offline_payment.currency)
+    end
+  end
+
+  def test_update
+    with_vcr do
+      recipient = create_recipient
+      offline_payment = @client.offline_payment.create(
+        recipient.id,
+        {
+          amount: '10.00',
+          currency: 'EUR',
+          category: 'services'
+        }
+      )
+
+      assert_not_nil(offline_payment)
+
+      response = @client.offline_payment.update(
+        recipient.id,
+        offline_payment.id,
+        {
+          category: 'royalties'
+        }
+      )
+
+      assert_true(response)
+    end
+  end
+
+  def test_delete
+    with_vcr do
+      recipient = create_recipient
+      offline_payment = @client.offline_payment.create(
+        recipient.id,
+        {
+          amount: '10.00',
+          currency: 'EUR',
+          category: 'services'
+        }
+      )
+
+      assert_not_nil(offline_payment)
+
+      response = @client.offline_payment.delete(recipient.id, offline_payment.id)
+
+      assert_true(response)
+    end
+  end
+
+  def test_search
+    with_vcr do
+      recipient = create_recipient
+      offline_payment = @client.offline_payment.create(
+        recipient.id,
+        {
+          amount: '10.00',
+          currency: 'EUR',
+          category: 'services'
+        }
+      )
+
+      assert_not_nil(offline_payment)
+
+      offline_payments = @client.offline_payment.search(
+        recipient.id
+      )
+
+      assert_true(offline_payments.count.positive?)
+    end
+  end
+end

data/test/integration/PaymentTest.rb

@@ -0,0 +1,73 @@
+require_relative '../test_helper'
+
+class PaymentTest < Test::Unit::TestCase
+  include TestHelper
+
+  def recipient
+    uuid = SecureRandom.uuid.to_s
+    recipient = @client.recipient.create(
+      type: 'individual',
+      firstName: 'Tom',
+      lastName: 'Jones',
+      email: "test.batch#{uuid}@example.com",
+      address: {
+        street1: '123 Wolfstrasse',
+        city: 'Berlin',
+        country: 'DE',
+        postalCode: '123123'
+      }
+    )
+    @client.recipient_account.create(recipient.id, type: 'bank-transfer', currency: 'EUR', country: 'DE', iban: 'DE89 3704 0044 0532 0130 00')
+    recipient
+  end
+
+  def batch
+    @batch ||= @client.batch.create(sourceCurrency: 'USD', description: 'Integration Test Create')
+  end
+
+  def test_crud
+    with_vcr do
+      payment = @client.payment.create(
+        batch.id,
+        sourceAmount: '10.00',
+        sourceCurrency: 'USD',
+        recipient: { id: recipient.id }
+      )
+
+      assert_not_nil(payment)
+      assert_not_nil(payment.id)
+      assert_equal('10.00', payment.sourceAmount)
+      assert_equal('USD', payment.sourceCurrency)
+
+      payment = @client.payment.find(batch.id, payment.id)
+      assert_not_nil(payment)
+
+      update_response = @client.payment.update(
+        batch.id,
+        payment.id,
+        sourceAmount: '20.00',
+        sourceCurrency: 'USD'
+      )
+
+      assert_not_nil(update_response)
+
+      response = @client.payment.delete(batch.id, payment.id)
+      assert_true(response)
+    end
+  end
+
+  def test_search
+    with_vcr do
+      @client.payment.create(
+        batch.id,
+        sourceAmount: '10.00',
+        sourceCurrency: 'USD',
+        recipient: { id: recipient.id }
+      )
+
+      result = @client.payment.search(batch.id)
+      assert_not_nil(result)
+      assert_true(result.count.positive?)
+    end
+  end
+end

data/test/integration/RecipientAccountTest.rb

@@ -0,0 +1,52 @@
+require_relative '../test_helper'
+
+class RecipientAccountTest < Test::Unit::TestCase
+  include TestHelper
+
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/BlockLength
+  def test_basic_crud
+    with_vcr do
+      recipient = @client.recipient.create(
+        type: 'individual',
+        firstName: 'Tom',
+        lastName: 'Jones',
+        email: "test.create#{uuid}@example.com"
+      )
+      recipient_account = @client.recipient_account.create(
+        recipient.id, type: 'bank-transfer',
+                      currency: 'EUR',
+                      country: 'DE',
+                      iban: 'DE89 3704 0044 0532 0130 00'
+      )
+
+      assert_not_nil(recipient_account)
+      assert_equal(recipient_account.type, 'bank-transfer')
+      assert_equal(recipient_account.currency, 'EUR')
+
+      recipient_account = @client.recipient_account.update(
+        recipient.id, recipient_account.id,
+        primary: true
+      )
+
+      assert_not_nil(recipient_account)
+      assert_equal(recipient_account.type, 'bank-transfer')
+      assert_equal(recipient_account.currency, 'EUR')
+      assert_equal(recipient_account.primary, true)
+
+      recipient_account = @client.recipient_account.find(
+        recipient.id, recipient_account.id
+      )
+
+      assert_not_nil(recipient_account)
+
+      response = @client.recipient_account.delete(
+        recipient.id, recipient_account.id
+      )
+
+      assert_true(response)
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/BlockLength
+end

data/test/integration/RecipientTest.rb

@@ -0,0 +1,176 @@
+require_relative '../test_helper'
+
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/BlockLength
+class RecipientTest < Test::Unit::TestCase
+  include TestHelper
+
+  def test_create
+    with_vcr do
+      response = @client.recipient.create(
+        type: 'individual',
+        firstName: 'Tom',
+        lastName: 'Jones',
+        email: "test.create#{uuid}@example.com"
+      )
+      assert_not_nil(response)
+      assert_equal(response.firstName, 'Tom')
+      assert_equal(response.lastName, 'Jones')
+      assert_not_nil(response.id)
+    end
+  end
+
+  def test_lifecycle
+    with_vcr do
+      recipient = @client.recipient.create(
+        type: 'individual',
+        firstName: 'Tom',
+        lastName: 'Jones',
+        email: "test.create#{uuid}@example.com"
+      )
+      assert_not_nil(recipient)
+      assert_equal(recipient.firstName, 'Tom')
+      assert_equal(recipient.status, 'incomplete')
+
+      response = @client.recipient.update(recipient.id, firstName: 'Bob')
+      assert_true(response)
+
+      recipient = @client.recipient.find(recipient.id)
+      assert_equal(recipient.firstName, 'Bob')
+
+      response = @client.recipient.delete(recipient.id)
+      assert_true(response)
+
+      recipient = @client.recipient.find(recipient.id)
+      assert_equal(recipient.status, 'archived')
+    end
+  end
+
+  def test_account
+    with_vcr do
+      recipient = @client.recipient.create(
+        type: 'individual',
+        firstName: 'Tom',
+        lastName: 'Jones',
+        email: "test.create#{uuid}@example.com",
+        address: {
+          street1: '123 Wolfstrasse',
+          city: 'Berlin',
+          country: 'DE',
+          postalCode: '123123'
+        }
+      )
+      assert_not_nil(recipient)
+      assert_equal(recipient.firstName, 'Tom')
+      assert_equal(recipient.lastName, 'Jones')
+      assert_not_nil(recipient.id)
+      assert_true(recipient.routeMinimum.to_i >= 0)
+
+      account = @client.recipient_account.create(recipient.id, type: 'bank-transfer', currency: 'EUR', country: 'DE', iban: 'DE89 3704 0044 0532 0130 00')
+      assert_not_nil(account)
+
+      account = @client.recipient_account.create(recipient.id, type: 'bank-transfer', currency: 'EUR', country: 'FR', iban: 'FR14 2004 1010 0505 0001 3M02 606')
+      assert_not_nil(account)
+
+      findAccount = @client.recipient_account.find(recipient.id, account.id)
+      assert_equal(account.id, findAccount.id)
+
+      accountList = @client.recipient_account.all(recipient.id)
+      assert_equal(2, accountList.count)
+      assert_equal(accountList[0].currency, 'EUR')
+
+      result = @client.recipient_account.delete(recipient.id, account.id)
+      assert_true(result)
+
+      accountList = @client.recipient_account.all(recipient.id)
+      assert_equal(1, accountList.count)
+    end
+  end
+
+  def test_delete_multiple
+    with_vcr do
+      recipient1 = @client.recipient.create(
+        type: 'individual',
+        firstName: 'Tom',
+        lastName: 'Jones',
+        email: "test.create#{uuid}@example.com"
+      )
+      assert_not_nil(recipient1)
+      assert_equal(recipient1.firstName, 'Tom')
+      assert_equal(recipient1.status, 'incomplete')
+
+      recipient2 = @client.recipient.create(
+        type: 'individual',
+        firstName: 'Tom',
+        lastName: 'Jones',
+        email: "test.create#{uuid}@example.com"
+      )
+      assert_not_nil(recipient2)
+      assert_equal(recipient2.firstName, 'Tom')
+      assert_equal(recipient2.status, 'incomplete')
+
+      response = @client.recipient.delete([recipient1.id, recipient2.id])
+      assert_true(response)
+
+      recipient1 = @client.recipient.find(recipient1.id)
+      assert_equal(recipient1.status, 'archived')
+
+      recipient2 = @client.recipient.find(recipient2.id)
+      assert_equal(recipient2.status, 'archived')
+    end
+  end
+
+  def test_find_logs
+    with_vcr do
+      recipient = @client.recipient.create(
+        type: 'individual',
+        firstName: 'Tom',
+        lastName: 'Jones',
+        email: "test.create#{uuid}@example.com"
+      )
+      assert_not_nil(recipient)
+      assert_equal(recipient.firstName, 'Tom')
+      assert_equal(recipient.status, 'incomplete')
+
+      @client.recipient.update(recipient.id, firstName: 'John')
+      logs = @client.recipient.find_logs(recipient.id)
+
+      assert_equal(Trolley::Utils::PaginatedArray, logs.class)
+      assert_equal(1, logs.page)
+      assert_equal('create', logs.first.type)
+      assert_boolean(true, @client.recipient.delete(recipient.id))
+    end
+  end
+
+  def test_find_payments
+    with_vcr do
+      recipient = @client.recipient.create(
+        type: 'individual',
+        firstName: 'Tom',
+        lastName: 'Jones',
+        email: "test.create#{uuid}@example.com"
+      )
+      recipient_account = @client.recipient_account.create(recipient.id, type: 'bank-transfer', currency: 'EUR', country: 'DE', iban: 'DE89 3704 0044 0532 0130 00')
+
+      batch = @client.batch.create(
+        sourceCurrency: 'USD', description: 'Integration Test Payments', payments: [
+          { targetAmount: '10.00', targetCurrency: 'EUR', recipient: { id: recipient.id } },
+          { sourceAmount: '10.00', recipient: { id: recipient.id } }
+        ]
+      )
+
+      payments = @client.recipient.find_payments(recipient.id)
+      assert_equal(payments.count, 2)
+      assert_equal(payments[0].recipient['id'], recipient.id)
+      assert_equal(payments[1].recipient['id'], recipient.id)
+      assert_equal(payments.map(&:amount), ['10.00', '10.00'])
+
+      assert_boolean(true, @client.batch.delete(batch.id))
+      assert_boolean(true, @client.recipient_account.delete(recipient.id, recipient_account.id))
+      assert_boolean(true, @client.recipient.delete(recipient.id))
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength
+# rubocop:enable Metrics/MethodLength
+# rubocop:enable Metrics/BlockLength

data/test/test_helper.rb

@@ -0,0 +1,45 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter '/test/'
+  coverage_dir 'coverage'
+end
+
+require_relative '../lib/trolley'
+require 'dotenv/load'
+require 'test/unit'
+require 'securerandom'
+require 'webmock/test_unit'
+require 'vcr'
+
+module TestHelper
+  def setup
+    @fixture_test_path = "test/fixtures/#{self.class.name.split('::').last}"
+    @test_case = method_name.chomp('_')
+
+    @client = Trolley.client(
+      ENV.fetch('SANDBOX_API_KEY'),
+      ENV.fetch('SANDBOX_SECRET_KEY'),
+      api_base: ENV['API_BASE'],
+      proxy_uri: ENV['PROXY_URI']
+    )
+
+    VCR.configure do |config|
+      config.cassette_library_dir = @fixture_test_path
+      config.hook_into :webmock
+
+      config.before_record do |interaction|
+        interaction.request.headers.delete('Authorization')
+        interaction.request.headers.delete('Trolley-Source')
+      end
+    end
+  end
+
+  def uuid
+    SecureRandom.uuid.to_s
+  end
+
+  def with_vcr(&block)
+    VCR.use_cassette(@test_case, &block)
+  end
+end

data/test/unit/ClientRequestTest.rb

@@ -0,0 +1,54 @@
+require_relative '../../lib/trolley'
+require 'test/unit'
+require 'webmock/test_unit'
+
+class ClientRequestTest < Test::Unit::TestCase
+  def setup
+    @config = Trolley::Configuration.new('key', 'secret', api_base: 'http://api.local.dev:3000')
+    @client = Trolley::Client.new(@config)
+  end
+
+  def test_request_posts_json_body_with_signed_headers
+    stub_request(:post, 'http://api.local.dev:3000/v1/recipients')
+      .with(
+        body: '{"type":"individual"}',
+        headers: {
+          'Authorization' => /^prsign key:/,
+          'Content-Type' => 'application/json',
+          'Trolley-Source' => "ruby-sdk_#{Trolley::VERSION}"
+        }
+      )
+      .to_return(status: 201, body: '{"ok":true}')
+
+    response = @client.request('POST', '/v1/recipients', type: 'individual')
+
+    assert_equal '{"ok":true}', response
+    assert_requested :post, 'http://api.local.dev:3000/v1/recipients'
+  end
+
+  def test_request_delete_supports_json_body
+    stub_request(:delete, 'http://api.local.dev:3000/v1/recipients')
+      .with(body: '{"ids":["R-123"]}')
+      .to_return(status: 200, body: '{"ok":true}')
+
+    @client.request('DELETE', '/v1/recipients', ids: ['R-123'])
+
+    assert_requested :delete, 'http://api.local.dev:3000/v1/recipients'
+  end
+
+  def test_request_accepts_204_response
+    stub_request(:delete, 'http://api.local.dev:3000/v1/recipients/R-123')
+      .to_return(status: 204, body: '')
+
+    assert_nil @client.request('DELETE', '/v1/recipients/R-123')
+  end
+
+  def test_gateway_exposes_request_without_changing_existing_accessors
+    gateway = Trolley.client('key', 'secret', api_base: 'http://api.local.dev:3000')
+
+    assert_respond_to gateway, :request
+    assert_respond_to gateway, :recipient
+    assert_respond_to gateway, :batch
+    assert_respond_to gateway, :invoice
+  end
+end

data/{spec → test}/unit/ConfigurationTest.rb

@@ -33,7 +33,7 @@ class ConfigurationTest < Test::Unit::TestCase
   def test_invalid_proxy_uri
     proxy_uri = 'not_://*a_valid_proxy'
     assert_raise Trolley::Configuration::InvalidProxyAddress.new("Invalid proxy provided to configuration: #{proxy_uri}") do
-      Trolley::Configuration.new('k', 's', proxy_uri: proxy_uri).proxy
+      Trolley::Configuration.new('k', 's', proxy_uri:).proxy
     end
   end