payload-api 0.4.1 → 0.6.0

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

data/spec/payload/arm/arm_request_query_spec.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "payload"
+require "payload/arm/object"
+
+RSpec.describe Payload::ARMRequest do
+  describe "#group_by" do
+    let(:instance) { described_class.new(Payload::Invoice, nil) }
+
+    it "appends to group_by and returns self" do
+      year_attr = Payload::Attr.new("year", Payload::Attr.new("created_at"))
+      year_attr.call
+      result = instance.group_by(year_attr, Payload::Attr.status)
+      expect(result).to be(instance)
+      expect(instance.instance_variable_get(:@group_by).map(&:to_s)).to eq(["year(created_at)", "status"])
+    end
+
+    it "includes group_by in request params when all() is called" do
+      Payload::api_key = "test_key"
+      instance.instance_variable_set(:@cls, Payload::Invoice)
+
+      expect(instance).to receive(:_execute_request) do |_http, request|
+        query = request.path.split("?")[1]
+        expect(query).to include("group_by%5B0%5D=") # group_by[0]=
+        expect(query).to include("group_by%5B1%5D=") # group_by[1]=
+        QuerySpecMockResponse.new('{"object":"list","values":[]}')
+      end
+
+      instance.group_by("year(created_at)", "status").all()
+    end
+  end
+
+  describe "#order_by" do
+    let(:instance) { described_class.new(Payload::Account, nil) }
+
+    it "appends to order_by and returns self" do
+      result = instance.order_by("created_at", "desc(id)")
+      expect(result).to be(instance)
+      expect(instance.instance_variable_get(:@order_by)).to eq(["created_at", "desc(id)"])
+    end
+
+    it "includes order_by in request params when all() is called" do
+      Payload::api_key = "test_key"
+      instance.instance_variable_set(:@cls, Payload::Account)
+
+      expect(instance).to receive(:_execute_request) do |_http, request|
+        query = request.path.split("?")[1]
+        expect(query).to include("order_by%5B0%5D=created_at")
+        expect(query).to include("order_by%5B1%5D=desc%28id%29")
+        QuerySpecMockResponse.new('{"object":"list","values":[]}')
+      end
+
+      instance.order_by("created_at", "desc(id)").all()
+    end
+  end
+
+  describe "#limit and #offset" do
+    let(:instance) { described_class.new(Payload::Account, nil) }
+
+    it "sets limit and offset and returns self" do
+      result = instance.limit(10).offset(20)
+      expect(result).to be(instance)
+      expect(instance.instance_variable_get(:@limit)).to eq(10)
+      expect(instance.instance_variable_get(:@offset)).to eq(20)
+    end
+
+    it "includes limit and offset in request params when all() is called" do
+      Payload::api_key = "test_key"
+      instance.instance_variable_set(:@cls, Payload::Account)
+
+      expect(instance).to receive(:_execute_request) do |_http, request|
+        query = request.path.split("?")[1]
+        expect(query).to include("limit=10")
+        expect(query).to include("offset=20")
+        QuerySpecMockResponse.new('{"object":"list","values":[]}')
+      end
+
+      instance.limit(10).offset(20).all()
+    end
+  end
+
+  describe "#request_params" do
+    it "merges filters, filter_objects, group_by, order_by, limit, offset into query params" do
+      instance = described_class.new(Payload::Transaction, nil)
+      instance.instance_variable_set(:@filters, { "fields" => "id,amount" })
+      instance.instance_variable_set(:@group_by, ["status"])
+      instance.instance_variable_set(:@order_by, ["desc(created_at)"])
+      instance.instance_variable_set(:@limit, 5)
+      instance.instance_variable_set(:@offset, 10)
+
+      filter_obj = Payload::ARMGreaterThan.new(Payload::Attr.amount, 100)
+      instance.instance_variable_set(:@filter_objects, [filter_obj])
+
+      params = instance.request_params
+
+      expect(params["fields"]).to eq("id,amount")
+      expect(params["group_by[0]"]).to eq("status")
+      expect(params["order_by[0]"]).to eq("desc(created_at)")
+      expect(params["limit"]).to eq("5")
+      expect(params["offset"]).to eq("10")
+      expect(params[filter_obj.attr]).to eq(filter_obj.opval)
+    end
+
+    it "is encoded as URL query string in _request (url.query = URI.encode_www_form(params))" do
+      Payload::api_key = "test_key"
+      session = Payload::Session.new("test_key", "https://api.test.com", "v2")
+      instance = described_class.new(Payload::Invoice, session)
+      instance.select("id", "status").filter_by(session.attr.status == "open").order_by("created_at").limit(5).offset(1)
+
+      expected_params = instance.request_params.dup
+
+      expect(instance).to receive(:_execute_request) do |_http, request|
+        query_str = request.path.split("?", 2)[1]
+        expect(query_str).not_to be_nil
+        decoded = URI.decode_www_form(query_str || "").to_h
+        expected_params.each do |key, value|
+          expect(decoded[key]).to eq(value.to_s)
+        end
+        expect(decoded).to include("fields" => "id,status", "limit" => "5", "offset" => "1")
+        expect(decoded.keys).to include("status", "order_by[0]")
+        QuerySpecMockResponse.new('{"object":"list","values":[]}')
+      end
+
+      instance.all()
+    end
+  end
+
+  describe "#[] (slice)" do
+    let(:instance) { described_class.new(Payload::Account, nil) }
+
+    it "raises TypeError for non-Range key" do
+      expect { instance["foo"] }.to raise_error(TypeError, /invalid key or index/)
+      expect { instance[5] }.to raise_error(TypeError, /invalid key or index/)
+    end
+
+    it "raises ArgumentError for negative begin" do
+      expect { instance[-1..10] }.to raise_error(ArgumentError, /Negative slice indices not supported/)
+    end
+
+    it "raises ArgumentError for negative end" do
+      expect { instance[0..-5] }.to raise_error(ArgumentError, /Negative slice indices not supported/)
+    end
+
+    it "calls offset(begin).limit(size).all() for a range and returns result" do
+      Payload::api_key = "test_key"
+      instance.instance_variable_set(:@cls, Payload::Account)
+
+      expect(instance).to receive(:_execute_request) do |_http, request|
+        query = request.path.split("?")[1]
+        expect(query).to include("offset=10")
+        expect(query).to include("limit=10")
+        QuerySpecMockResponse.new('{"object":"list","values":[{"id":"acct_1","object":"customer"}]}')
+      end
+
+      result = instance[10..19]
+      expect(result).to be_an(Array)
+      expect(result.size).to eq(1)
+      expect(result[0].id).to eq("acct_1")
+    end
+  end
+
+  describe "#filter_by with pl.attr filter objects" do
+    it "extracts ARM filter objects and merges their attr/opval into request params" do
+      session = Payload::Session.new("test_key", "https://api.test.com", "v2")
+      instance = described_class.new(Payload::Transaction, session)
+      pl = session
+      filter_expr = (pl.attr.amount > 100) | (pl.attr.amount < 200)
+
+      instance.filter_by(filter_expr)
+
+      expect(instance.instance_variable_get(:@filter_objects)).to include(be_a(Payload::ARMFilter))
+      params = instance.request_params
+      expect(params.keys).to include(filter_expr.attr)
+      expect(params[filter_expr.attr]).to eq(filter_expr.opval)
+    end
+
+    it "builds GET request with filter object serialized in query string" do
+      Payload::api_key = "test_key"
+      session = Payload::Session.new("test_key", "https://api.test.com", "v2")
+      instance = described_class.new(Payload::Transaction, session)
+      filter_expr = session.attr.amount > 100
+
+      instance.filter_by(filter_expr)
+
+      expect(instance).to receive(:_execute_request) do |_http, request|
+        query = request.path.split("?")[1]
+        expect(query).to include("amount=")
+        expect(query).to include("%3E100") # URL-encoded ">100"
+        QuerySpecMockResponse.new('{"object":"list","values":[]}')
+      end
+
+      instance.all()
+    end
+  end
+
+  describe "#filter_by with multiple filters" do
+    it "accumulates multiple filter objects and merges keyword filters into @filters" do
+      instance = described_class.new(Payload::Invoice, nil)
+      f1 = Payload::ARMEqual.new(Payload::Attr.status, "open")
+      f2 = Payload::ARMGreaterThan.new(Payload::Attr.amount, 50)
+
+      instance.filter_by(f1).filter_by(f2).filter_by(custom_key: "value")
+
+      fo = instance.instance_variable_get(:@filter_objects)
+      expect(fo).to include(f1, f2)
+      params = instance.request_params
+      expect(params["status"]).to eq("open")
+      expect(params["amount"]).to eq(">50")
+      expect(instance.instance_variable_get(:@filters)[:custom_key]).to eq("value")
+    end
+  end
+end
+
+class QuerySpecMockResponse
+  def initialize(body = '{"object":"list","values":[]}')
+    @body = body
+  end
+
+  def code
+    "200"
+  end
+
+  def body
+    @body
+  end
+end