payload-api 0.4.1 → 0.5.0

data/spec/objects/v1/payment_method_spec.rb

@@ -0,0 +1,106 @@
+require 'payload'
+require 'payload/arm/object'
+require_relative '../../support/helpers'
+
+RSpec.describe 'Payment Method Integration Tests - V1' do
+  include_context 'test helpers'
+
+  let(:session) { Payload::Session.new(Payload.api_key, Payload.api_url, 1) }
+  let(:h) { V1Helpers.new(session) }
+  let(:proc_account) { h.create_processing_account }
+
+  describe 'Payment Methods' do
+    it 'creates a payment with card' do
+      card_payment = h.create_card_payment(proc_account.id)
+      expect(card_payment.status).to eq('processed')
+    end
+
+    it 'creates a payment with bank account' do
+      bank_payment = h.create_bank_payment
+      expect(bank_payment.status).to eq('processed')
+    end
+
+    it 'filters payments' do
+      rand_description = (0...10).map { ('a'..'z').to_a[rand(26)] }.join
+
+      amounts = [90.0, 100.0, 110.0]
+      card_payments = []
+      amounts.each do |amount|
+        card_payment = h.create_card_payment(proc_account.id, amount: amount, description: rand_description)
+        card_payments << card_payment
+      end
+
+      payments = session.Transaction.filter_by(
+        type: 'payment',
+        amount: '100',
+        description: rand_description
+      ).all
+
+      expect(payments.length).to be == 1
+      expect(payments.map(&:id)).to include(card_payments[1].id)
+    end
+
+    it 'voids a card payment' do
+      card_payment = h.create_card_payment(proc_account.id)
+      card_payment.update(status: 'voided')
+      expect(card_payment.status).to eq('voided')
+    end
+
+    it 'voids a bank payment' do
+      bank_payment = h.create_bank_payment
+      bank_payment.update(status: 'voided')
+      expect(bank_payment.status).to eq('voided')
+    end
+
+    it 'refunds a card payment' do
+      card_payment = h.create_card_payment(proc_account.id)
+      refund = h.create_refund(card_payment)
+
+      expect(refund.type).to eq('refund')
+      expect(refund.amount).to eq(card_payment.amount)
+    end
+
+    it 'partially refunds a card payment' do
+      card_payment = h.create_card_payment(proc_account.id)
+      amount = (card_payment.amount/2).round(2) # rounded to 2 decimal places
+      refund = h.create_refund(card_payment, amount: amount)
+
+      expect(refund.type).to eq('refund')
+      expect(refund.amount).to eq(amount)
+    end
+
+    it 'creates a blind refund for card payment' do
+      refund = h.create_blind_refund(10, proc_account.id)
+
+      expect(refund.type).to eq('refund')
+      expect(refund.amount).to eq(10)
+    end
+
+    it 'refunds a bank payment' do
+      bank_payment = h.create_bank_payment
+      refund = h.create_refund(bank_payment)
+
+      expect(refund.type).to eq('refund')
+      expect(refund.amount).to eq(bank_payment.amount)
+    end
+
+    it 'partially refunds a bank payment' do
+      bank_payment = h.create_bank_payment
+      amount = (bank_payment.amount/2).round(2) # rounded to 2 decimal places
+      refund = h.create_refund(bank_payment, amount: amount)
+
+      expect(refund.type).to eq('refund')
+      expect(refund.amount).to eq(amount)
+    end
+
+    it 'raises error for invalid payment method type' do
+      expect {
+        session.Transaction.create(
+          type: 'invalid',
+          card_number: '4242 4242 4242 4242',
+          expiry: '12/29'
+        )
+      }.to raise_error(Payload::InvalidAttributes)
+    end
+  end
+end

data/spec/objects/{payment_spec.rb → v1/payment_spec.rb}

@@ -1,7 +1,7 @@
 require "payload"
 require "payload/arm/object"
 require 'base64'
-
+require_relative '../../support/helpers'
 
 RSpec.describe Payload::ARMRequest do
 
@@ -46,11 +46,10 @@ RSpec.describe Payload::ARMRequest do
                 payment = instance.create(
                   amount: 129.0,
                     customer_id: 'acct_3bW9JMoGYQul5fCIa9f8q',
-                    allocations: [
-                        Payload::PaymentItem.new(
-                            invoice_id: 'inv_3eNP6uf94xHTXr0rMyvZJ'
-                        )
-                    ],
+                    allocations: [{
+                        entry_type: 'payment',
+                        invoice_id: 'inv_3eNP6uf94xHTXr0rMyvZJ'
+                    }],
                 )
 
                 expect(payment.id).to eq($test_id)

data/spec/objects/v1/session_spec.rb

@@ -0,0 +1,89 @@
+require 'payload'
+require 'payload/arm/object'
+require 'payload/arm/session'
+require 'date'
+require_relative '../../support/helpers'
+
+RSpec.describe 'Session Integration Tests' do
+  include_context 'test helpers'
+
+  describe 'Session' do
+    let(:session) { Payload::Session.new(Payload.api_key, Payload.api_url, 1) }
+
+    it 'creates a customer account with session' do
+      customer_account = session.Customer.create(name: 'Test', email: 'test@example.com')
+      expect(customer_account.id).to be_truthy
+    end
+
+    it 'deletes with session' do
+      customer_account = session.Customer.create(name: 'Test', email: 'test@example.com')
+      customer_account.delete
+      
+      expect {
+        session.Customer.get(customer_account.id)
+      }.to raise_error(Payload::NotFound)
+    end
+
+    it 'creates multiple accounts with session' do
+      rand_email1 = (0...5).map { ('a'..'z').to_a[rand(26)] }.join + '@example.com'
+      rand_email2 = (0...5).map { ('a'..'z').to_a[rand(26)] }.join + '@example.com'
+
+      session.create([
+        session.Customer.new(email: rand_email1, name: 'Matt Perez'),
+        session.Customer.new(email: rand_email2, name: 'Andrea Kearney')
+      ])
+
+      get_account_1 = session.Customer.filter_by(email: rand_email1).all[0]
+      get_account_2 = session.Customer.filter_by(email: rand_email2).all[0]
+
+      expect(get_account_1).to be_truthy
+      expect(get_account_2).to be_truthy
+    end
+
+    it 'pages and orders results with session' do
+      session.create([
+        session.Customer.new(email: 'account1@example.com', name: 'Randy Robson'),
+        session.Customer.new(email: 'account2@example.com', name: 'Brandy Bobson'),
+        session.Customer.new(email: 'account3@example.com', name: 'Mandy Johnson')
+      ])
+
+      customers = session.Customer.filter_by(order_by: 'created_at', limit: 3, offset: 1).all
+
+      expect(customers.length).to eq(3)
+      require 'time'
+      expect(Time.parse(customers[0].created_at)).to be <= Time.parse(customers[1].created_at)
+      expect(Time.parse(customers[1].created_at)).to be <= Time.parse(customers[2].created_at)
+    end
+
+    it 'updates customer with session' do
+      customer_account = session.Customer.create(name: 'Test', email: 'test@example.com')
+      customer_account.update(email: 'test2@example.com')
+      expect(customer_account.email).to eq('test2@example.com')
+    end
+
+    it 'updates multiple accounts with session' do
+      customer_account_1 = session.Customer.create(name: 'Brandy', email: 'test1@example.com')
+      customer_account_2 = session.Customer.create(name: 'Sandy', email: 'test2@example.com')
+
+      updated_accounts = session.update([
+        [customer_account_1, { email: 'brandy@example.com' }],
+        [customer_account_2, { email: 'sandy@example.com' }]
+      ])
+
+      expect(updated_accounts[0].email).to eq('brandy@example.com')
+      expect(updated_accounts[1].email).to eq('sandy@example.com')
+    end
+
+    it 'gets customer with session' do
+      customer_account = session.Customer.create(name: 'Test', email: 'test@example.com')
+      expect(session.Customer.get(customer_account.id)).to be_truthy
+    end
+
+    it 'selects customer attributes with session' do
+      customer_account = session.Customer.create(name: 'Test', email: 'test@example.com')
+      selected = session.query(Payload::Customer).select('id').get(customer_account.id)
+      expect(selected['id']).to eq(customer_account.id)
+    end
+  end
+end
+

data/spec/objects/v1/transaction_spec.rb

@@ -0,0 +1,55 @@
+require 'payload'
+require 'payload/arm/object'
+require_relative '../../support/helpers'
+
+RSpec.describe 'Transaction Integration Tests - V1' do
+  include_context 'test helpers'
+
+  let(:session) { Payload::Session.new(Payload.api_key, Payload.api_url, 1) }
+  let(:h) { V1Helpers.new(session) }
+  let(:proc_account) { h.create_processing_account }
+
+  describe 'Transactions' do
+
+    it 'has empty transaction ledger' do
+      card_payment = h.create_card_payment(proc_account.id)
+      transaction = session.Transaction.select('*', 'ledger').get(card_payment.id)
+      expect(transaction.ledger).to eq([])
+    end
+
+    it 'tests unified payout batching' do
+      h.create_blind_refund(10, proc_account.id)
+
+      transactions = session.Transaction.select('*', 'ledger')
+        .filter_by(type: 'refund', processing_id: proc_account.id)
+        .all
+
+      expect(transactions.length).to eq(1)
+      expect(transactions[0].processing_id).to eq(proc_account.id)
+    end
+
+    it 'gets transactions' do
+      h.create_card_payment(proc_account.id)
+      payments = session.Transaction.filter_by(status: 'processed', type: 'payment').all
+      expect(payments.length).to be > 0
+    end
+
+    it 'checks risk flag' do
+      card_payment = h.create_card_payment(proc_account.id)
+      expect(card_payment.risk_flag).to eq('allowed')
+    end
+
+    it 'updates processed transaction' do
+      card_payment = h.create_card_payment(proc_account.id)
+      card_payment.update(status: 'voided')
+      expect(card_payment.status).to eq('voided')
+    end
+
+    it 'raises error for transaction not found' do
+      expect {
+        session.Transaction.get('invalid')
+      }.to raise_error(Payload::NotFound)
+    end
+  end
+end
+

data/spec/objects/v2/account_spec.rb

@@ -0,0 +1,211 @@
+require 'payload'
+require 'payload/arm/object'
+require_relative '../../support/helpers'
+
+RSpec.describe 'Account Integration Tests - V2' do
+  include_context 'test helpers'
+
+  let(:session) { Payload::Session.new(Payload.api_key, Payload.api_url, 2) }
+
+  describe 'Customer Account' do
+    it 'creates a customer account' do
+      customer_account = session.Account.create(
+        type: 'customer',
+        name: 'Test',
+        contact_details: {
+          email: 'test@example.com'
+        }
+      )
+      expect(customer_account.id).to be_truthy
+    end
+
+    it 'deletes a customer account' do
+      cust_account = session.Account.create(
+        type: 'customer',
+        name: 'Test',
+        contact_details: {
+          email: 'test@example.com'
+        }
+      )
+      cust_account.delete
+
+      expect {
+        session.Account.get(cust_account.id)
+      }.to raise_error(Payload::NotFound)
+    end
+
+    it 'creates multiple accounts' do
+      rand_email1 = (0...5).map { ('a'..'z').to_a[rand(26)] }.join + '@example.com'
+      rand_email2 = (0...5).map { ('a'..'z').to_a[rand(26)] }.join + '@example.com'
+
+      name1 = 'Matt Perez'
+      name2 = 'Andrea Kearney'
+
+      accounts_to_create = [
+        session.Account.new(type: 'customer', contact_details: { email: rand_email1 }, name: name1),
+        session.Account.new(type: 'customer', contact_details: { email: rand_email2 }, name: name2)
+      ]
+      session.create(accounts_to_create)
+
+      get_account_1 = session.Account.filter_by(type: 'customer', 'contact_details[email]': rand_email1).all[0]
+      get_account_2 = session.Account.filter_by(type: 'customer', 'contact_details[email]': rand_email2).all[0]
+
+      expect(get_account_1).to be_truthy
+      expect(get_account_2).to be_truthy
+    end
+
+    it 'gets a processing account' do
+      orgs = session.Profile.all()
+      org = orgs[0]
+      proc_account = session.Account.create(
+        type: 'processing',
+        name: 'Processing Account',
+        processing: {
+          status:      { funding: 'pending' },
+          settings_id: org.processing_settings_id,
+        },
+        payment_methods: [session.PaymentMethod.new(
+          type: 'bank_account',
+          bank_account: {
+            account_number: '123456789',
+            routing_number: '036001808',
+            account_type:   'checking'
+          },
+          billing_address: {
+            postal_code: '11111',
+          },
+          account_defaults: {
+            funding: 'all',
+          }
+        )],
+        entity: {
+          type:        'business',
+          legal_name:  'Example',
+          country:     'US',
+          phone_number: '123 123-1234',
+          tax_id:      { value: '123 12 1234' },
+          address: {
+            address_line_1: '123 Example St',
+            city:           'New York',
+            state_province: 'NY',
+            postal_code:    '11111',
+          },
+          business: {
+            category: 'real_estate',
+            structure: 'llc',
+            website:  'https://example.com',
+            formation: {
+              state_province: 'NY',
+              date:           '2019-10-01',
+            },
+            primary_contact: {
+              name:  'John Smith',
+              email: 'johnsmith@gmail.com',
+            },
+            stakeholders: [
+              {
+                country: 'US',
+                personal_information: {
+                  full_name:    'John Smith',
+                  email:        'johnsmith@gmail.com',
+                  birth_date:   '1990-05-10',
+                  phone_number: '123 123-1234',
+                },
+                address: {
+                  address_line_1: '123 Example St',
+                  city:           'New York',
+                  state_province: 'NY',
+                  postal_code:    '11111',
+                },
+                govt_id: {
+                  tax_id: { value: '123 12 1234' },
+                },
+                association: {
+                  roles: ['principal_officer'],
+                  title: 'CEO',
+                  ownership: {
+                    percentage:  100,
+                    years_owned: 5,
+                  },
+                },
+              },
+            ],
+          },
+        },
+      )
+      retrieved = session.Account.get(proc_account.id)
+      expect(retrieved).to be_truthy
+      expect(proc_account.processing['status']['funding']).to eq('pending')
+    end
+
+    it 'pages and orders results' do
+      accounts_to_create = [
+        session.Account.new(type: 'customer', contact_details: { email: 'account1@example.com' }, name: 'Randy Robson'),
+        session.Account.new(type: 'customer', contact_details: { email: 'account2@example.com' }, name: 'Brandy Bobson'),
+        session.Account.new(type: 'customer', contact_details: { email: 'account3@example.com' }, name: 'Mandy Johnson')
+      ]
+      session.create(accounts_to_create)
+      customers = session.Account.filter_by(type: 'customer', order_by: 'created_at', limit: 3, offset: 1).all
+
+      expect(customers.length).to eq(3)
+      require 'time'
+      expect(Time.parse(customers[0].created_at)).to be <= Time.parse(customers[1].created_at)
+      expect(Time.parse(customers[1].created_at)).to be <= Time.parse(customers[2].created_at)
+    end
+
+    it 'updates a customer' do
+      cust_account = session.Account.create(
+        type: 'customer',
+        name: 'Test',
+        contact_details: {
+          email: 'test@example.com'
+        }
+      )
+      cust_account.update(contact_details: { email: 'test2@example.com' })
+      expect(cust_account.contact_details['email']).to eq('test2@example.com')
+    end
+
+    it 'updates multiple accounts' do
+      customer_account_1 = session.Account.create(
+        type: 'customer',
+        name: 'Brandy',
+        contact_details: { email: 'test1@example.com' }
+      )
+      customer_account_2 = session.Account.create(
+        type: 'customer',
+        name: 'Sandy',
+        contact_details: { email: 'test2@example.com' }
+      )
+      updated_accounts = session.update([
+        [customer_account_1, { contact_details: { email: 'brandy@example.com' } }],
+        [customer_account_2, { contact_details: { email: 'sandy@example.com' } }]
+      ])
+
+      expect(updated_accounts[0].contact_details['email']).to eq('brandy@example.com')
+      expect(updated_accounts[1].contact_details['email']).to eq('sandy@example.com')
+    end
+
+    it 'gets a customer' do
+      cust_account = session.Account.create(
+        type: 'customer',
+        name: 'Test',
+        contact_details: {
+          email: 'test@example.com'
+        }
+      )
+      expect(session.Account.get(cust_account.id)).to be_truthy
+    end
+
+    it 'selects customer attributes' do
+      cust_account = session.Account.create(
+        type: 'customer',
+        name: 'Test',
+        contact_details: {
+          email: 'test@example.com'
+        }
+      )
+      selected = session.Account.select('id').get(cust_account.id)
+      expect(selected['id']).to eq(cust_account.id)
+    end
+  end
+end

data/spec/objects/v2/invoice_spec.rb

@@ -0,0 +1,53 @@
+require 'payload'
+require 'payload/arm/object'
+require 'date'
+require_relative '../../support/helpers'
+
+RSpec.describe 'Invoice Integration Tests - V2' do
+  include_context 'test helpers'
+
+  let(:session) { Payload::Session.new(Payload.api_key, Payload.api_url, 2) }
+  let(:h) { V2Helpers.new(session) }
+
+  let(:proc_account)       { h.create_processing_account }
+  let(:customer_account)   { h.create_customer_account }
+  let(:invoice)            { h.create_invoice(proc_account, customer_account) }
+
+  describe 'Invoice' do
+    it 'creates an invoice' do
+      inv = invoice
+      expect(inv.due_date).to eq(Date.today.strftime('%Y-%m-%d'))
+      expect(inv.status).to eq('unpaid')
+    end
+
+    it 'pays an invoice' do
+      inv = invoice
+      expect(inv.due_date).to eq(Date.today.strftime('%Y-%m-%d'))
+      expect(inv.status).to eq('unpaid')
+
+      amount = inv.totals['balance_due']
+
+      if inv.status != 'paid'
+        h.create_card_payment(
+          proc_account.id,
+          amount: amount,
+          description: 'Test Payment',
+          customer_id: customer_account.id,
+          invoice_id: inv.id
+        )
+      end
+
+      get_invoice = session.Invoice.get(inv.id)
+      expect(get_invoice.status).to eq('paid')
+    end
+
+    it 'deletes an invoice' do
+      inv = invoice
+      inv.delete
+
+      expect {
+        session.Invoice.get(inv.id)
+      }.to raise_error(Payload::NotFound)
+    end
+  end
+end

data/spec/objects/v2/payment_method_spec.rb

@@ -0,0 +1,106 @@
+require 'payload'
+require 'payload/arm/object'
+require_relative '../../support/helpers'
+
+RSpec.describe 'Payment Method Integration Tests - V2' do
+  include_context 'test helpers'
+
+  let(:session) { Payload::Session.new(Payload.api_key, Payload.api_url, 2) }
+  let(:h) { V2Helpers.new(session) }
+  let(:proc_account) { h.create_processing_account }
+
+  describe 'Payment Methods' do
+    it 'creates a payment with card' do
+      card_payment = h.create_card_payment(proc_account.id)
+      expect(card_payment.status['value']).to eq('processed')
+    end
+
+    it 'creates a payment with bank account' do
+      bank_payment = h.create_bank_payment
+      expect(bank_payment.status['value']).to eq('processed')
+    end
+
+    it 'filters payments' do
+      rand_description = (0...10).map { ('a'..'z').to_a[rand(26)] }.join
+
+      amounts = [90.0, 100.0, 110.0]
+      card_payments = []
+      amounts.each do |amount|
+        card_payment = h.create_card_payment(proc_account.id, amount: amount, description: rand_description)
+        card_payments << card_payment
+      end
+
+      payments = session.Transaction.filter_by(
+        type: 'payment',
+        amount: '100',
+        description: rand_description
+      ).all
+
+      expect(payments.length).to be == 1
+      expect(payments.map(&:id)).to include(card_payments[1].id)
+    end
+
+    it 'voids a card payment' do
+      card_payment = h.create_card_payment(proc_account.id)
+      card_payment.update(status: { value: 'voided' })
+      expect(card_payment.status['value']).to eq('voided')
+    end
+
+    it 'voids a bank payment' do
+      bank_payment = h.create_bank_payment
+      bank_payment.update(status: { value: 'voided' })
+      expect(bank_payment.status['value']).to eq('voided')
+    end
+
+    it 'refunds a card payment' do
+      card_payment = h.create_card_payment(proc_account.id)
+      refund = h.create_refund(card_payment)
+
+      expect(refund.type).to eq('refund')
+      expect(refund.amount).to eq(card_payment.amount)
+    end
+
+    it 'partially refunds a card payment' do
+      card_payment = h.create_card_payment(proc_account.id)
+      amount = (card_payment.amount/2).round(2) # rounded to 2 decimal places
+      refund = h.create_refund(card_payment, amount: amount)
+
+      expect(refund.type).to eq('refund')
+      expect(refund.amount).to eq(amount)
+    end
+
+    it 'creates a blind refund for card payment' do
+      refund = h.create_blind_refund(10, proc_account.id)
+
+      expect(refund.type).to eq('refund')
+      expect(refund.amount).to eq(10)
+    end
+
+    it 'refunds a bank payment' do
+      bank_payment = h.create_bank_payment
+      refund = h.create_refund(bank_payment)
+
+      expect(refund.type).to eq('refund')
+      expect(refund.amount).to eq(bank_payment.amount)
+    end
+
+    it 'partially refunds a bank payment' do
+      bank_payment = h.create_bank_payment
+      amount = (bank_payment.amount/2).round(2) # rounded to 2 decimal places
+      refund = h.create_refund(bank_payment, amount: amount)
+
+      expect(refund.type).to eq('refund')
+      expect(refund.amount).to eq(amount)
+    end
+
+    it 'raises error for invalid payment method type' do
+      expect {
+        session.Transaction.create(
+          type: 'invalid',
+          card_number: '4242 4242 4242 4242',
+          expiry: '12/30'
+        )
+      }.to raise_error(Payload::InvalidAttributes)
+    end
+  end
+end

data/spec/objects/v2/transaction_spec.rb

@@ -0,0 +1,48 @@
+require 'payload'
+require 'payload/arm/object'
+require_relative '../../support/helpers'
+
+RSpec.describe 'Transaction Integration Tests - V2' do
+  include_context 'test helpers'
+
+  let(:session) { Payload::Session.new(Payload.api_key, Payload.api_url, 2) }
+  let(:h) { V2Helpers.new(session) }
+  let(:proc_account) { h.create_processing_account }
+
+  describe 'Transactions' do
+
+    it 'has empty transaction ledger' do
+      card_payment = h.create_card_payment(proc_account.id)
+      transaction = session.Transaction.select('*', 'ledger').get(card_payment.id)
+      expect(transaction.ledger).to eq([])
+    end
+
+    it 'tests unified payout batching' do
+      h.create_blind_refund(10, proc_account.id)
+
+      transactions = session.Transaction.select('*', 'ledger')
+        .filter_by(type: 'refund', processing_id: proc_account.id)
+        .all
+
+      expect(transactions.length).to eq(1)
+    end
+
+    it 'gets transactions' do
+      h.create_card_payment(proc_account.id)
+      payments = session.Transaction.filter_by('status[value]': 'processed', type: 'payment', 'receiver[account_id]': proc_account.id).all
+      expect(payments.length).to be > 0
+    end
+
+    it 'updates processed transaction' do
+      card_payment = h.create_card_payment(proc_account.id)
+      card_payment.update(status: { value: 'voided' })
+      expect(card_payment.status['value']).to eq('voided')
+    end
+
+    it 'raises error for transaction not found' do
+      expect {
+        session.Transaction.get('invalid')
+      }.to raise_error(Payload::NotFound)
+    end
+  end
+end