payload-api 0.4.1 → 0.6.0

data/spec/objects/v1/access_token_spec.rb

@@ -0,0 +1,19 @@
+require 'payload'
+require 'payload/arm/object'
+require_relative '../../support/helpers'
+
+RSpec.describe 'Access Token Integration Tests' do
+  include_context 'test helpers'
+
+  let(:session) { Payload::Session.new(Payload.api_key, Payload.api_url, 1) }
+
+  describe 'Access Token' do
+    it 'creates a client token' do
+      client_token = session.ClientToken.create
+      expect(client_token.status).to eq('active')
+      expect(client_token.type).to eq('client')
+      expect(client_token.environ).to eq('test')
+    end
+  end
+end
+

data/spec/objects/v1/account_spec.rb

@@ -0,0 +1,97 @@
+require 'payload'
+require 'payload/arm/object'
+require_relative '../../support/helpers'
+
+RSpec.describe 'Account 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) }
+
+  describe 'Customer Account' do
+    it 'creates a customer account' do
+      customer_account = session.Customer.create(name: 'Test', email: 'test@example.com')
+      expect(customer_account.id).to be_truthy
+    end
+
+    it 'deletes a customer account' do
+      cust_account = session.Customer.create(name: 'Test', email: 'test@example.com')
+      cust_account.delete
+
+      expect {
+        session.Customer.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.Customer.new(email: rand_email1, name: name1),
+        session.Customer.new(email: rand_email2, name: name2)
+      ]
+      session.create(accounts_to_create)
+
+      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 'gets a processing account' do
+      proc_account = h.create_processing_account
+      retrieved = session.ProcessingAccount.get(proc_account.id)
+      expect(retrieved).to be_truthy
+      expect(retrieved.status).to eq('pending')
+    end
+
+    it 'pages and orders results' do
+      accounts_to_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')
+      ]
+      session.create(accounts_to_create)
+      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 a customer' do
+      cust_account = session.Customer.create(name: 'Test', email: 'test@example.com')
+      cust_account.update(email: 'test2@example.com')
+      expect(cust_account.email).to eq('test2@example.com')
+    end
+
+    it 'updates multiple accounts' 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 a customer' do
+      cust_account = session.Customer.create(name: 'Test', email: 'test@example.com')
+      expect(session.Customer.get(cust_account.id)).to be_truthy
+    end
+
+    it 'selects customer attributes' do
+      cust_account = session.Customer.create(name: 'Test', email: 'test@example.com')
+      selected = session.Customer.select('id').get(cust_account.id)
+      expect(selected['id']).to eq(cust_account.id)
+    end
+  end
+end

data/spec/objects/v1/billing_spec.rb

@@ -0,0 +1,54 @@
+require 'payload'
+require 'payload/arm/object'
+require_relative '../../support/helpers'
+
+RSpec.describe 'Billing 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) }
+
+  describe 'Billing Schedule' do
+    let(:billing_schedule) do
+      proc_account = h.create_processing_account
+      customer_account = h.create_customer_account
+      session.BillingSchedule.create(
+        start_date: '2019-01-01',
+        end_date: '2019-12-31',
+        recurring_frequency: 'monthly',
+        type: 'subscription',
+        customer_id: customer_account.id,
+        processing_id: proc_account.id,
+        charges: [
+          {
+            type: 'option_1',
+            amount: 39.99
+          }
+        ]
+      )
+    end
+
+    it 'creates a billing schedule' do
+      schedule = billing_schedule
+      expect(schedule.charges[0]['amount']).to eq(39.99)
+    end
+
+    it 'updates billing schedule frequency' do
+      schedule = billing_schedule
+      expect(schedule.charges[0]['amount']).to eq(39.99)
+
+      schedule.update(recurring_frequency: 'quarterly')
+      expect(schedule.recurring_frequency).to eq('quarterly')
+    end
+
+    it 'deletes a billing schedule' do
+      schedule = billing_schedule
+      schedule.delete
+      
+      expect {
+        session.BillingSchedule.get(schedule.id)
+      }.to raise_error(Payload::NotFound)
+    end
+  end
+end
+

data/spec/objects/v1/invoice_spec.rb

@@ -0,0 +1,53 @@
+require 'payload'
+require 'payload/arm/object'
+require 'date'
+require_relative '../../support/helpers'
+
+RSpec.describe 'Invoice 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 }
+  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.amount_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/v1/payment_link_spec.rb

@@ -0,0 +1,50 @@
+require 'payload'
+require 'payload/arm/object'
+require_relative '../../support/helpers'
+
+RSpec.describe 'Payment Link 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) }
+
+  describe 'Payment Link' do
+
+    it 'creates a one-time payment link' do
+      proc_account = h.create_processing_account
+      payment_link = h.create_payment_link_one_time(proc_account)
+
+      expect(payment_link.processing_id).to eq(proc_account.id)
+      expect(payment_link.type).to eq('one_time')
+    end
+
+    it 'creates a reusable payment link' do
+      proc_account = h.create_processing_account
+      payment_link = h.create_payment_link_reusable(proc_account)
+
+      expect(payment_link.processing_id).to eq(proc_account.id)
+      expect(payment_link.type).to eq('reusable')
+    end
+
+    it 'deletes a reusable payment link' do
+      proc_account = h.create_processing_account
+      payment_link = h.create_payment_link_reusable(proc_account)
+      payment_link.delete
+
+      expect {
+        session.PaymentLink.get(payment_link.id)
+      }.to raise_error(Payload::NotFound)
+    end
+
+    it 'deletes a one-time payment link' do
+      proc_account = h.create_processing_account
+      payment_link = h.create_payment_link_one_time(proc_account)
+      payment_link.delete
+
+      expect {
+        session.PaymentLink.get(payment_link.id)
+      }.to raise_error(Payload::NotFound)
+    end
+  end
+end
+

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
+