payload-api 0.4.1 → 0.5.0

data/spec/payload/arm/request_spec.rb

@@ -759,4 +759,262 @@ RSpec.describe Payload::ARMRequest do
             end
         end
     end
+
+    describe "API version header functionality" do
+
+        # Mock object for testing
+        class MockObject < Payload::ARMObject
+            @spec = { 'object' => 'mock_object', 'endpoint' => '/mock' }
+        end
+
+        context "when session.api_version is set" do
+            it "includes X-API-Version header in GET requests" do
+                $test_id = 'mock_' + rand(9000000...9999999).to_s
+
+                session = Payload::Session.new('test_key', 'https://api.test.com', '2.1')
+                instance = Payload::ARMRequest.new(MockObject, session)
+
+                expect(instance).to receive(:_execute_request) do |http, request|
+                    expect(request.method).to eq("GET")
+                    expect(request['X-API-Version']).to eq('2.1')
+
+                    class MockResponse
+                        def initialize
+                        end
+
+                        def code
+                            '200'
+                        end
+
+                        def body
+                            '{
+                                "object": "mock_object",
+                                "id": "' + $test_id + '"
+                            }'
+                        end
+                    end
+
+                    MockResponse.new
+                end
+
+                instance.get($test_id)
+            end
+        end
+
+        context "when session.api_version is nil" do
+            it "does not include X-API-Version header" do
+                $test_id = 'mock_' + rand(9000000...9999999).to_s
+
+                session = Payload::Session.new('test_key', 'https://api.test.com', nil)
+                instance = Payload::ARMRequest.new(MockObject, session)
+
+                expect(instance).to receive(:_execute_request) do |http, request|
+                    expect(request.method).to eq("GET")
+                    expect(request['X-API-Version']).to be_nil
+
+                    class MockResponse
+                        def initialize
+                        end
+
+                        def code
+                            '200'
+                        end
+
+                        def body
+                            '{
+                                "object": "mock_object",
+                                "id": "' + $test_id + '"
+                            }'
+                        end
+                    end
+
+                    MockResponse.new
+                end
+
+                instance.get($test_id)
+            end
+        end
+
+        context "when no session is provided" do
+            it "uses global Payload.api_version" do
+                $test_id = 'mock_' + rand(9000000...9999999).to_s
+
+                # Set global api_version
+                original_version = Payload.api_version
+                Payload.api_version = '2.2'
+
+                # Create request without session (will use global Payload module)
+                instance = Payload::ARMRequest.new(MockObject, nil)
+
+                expect(instance).to receive(:_execute_request) do |http, request|
+                    expect(request.method).to eq("GET")
+                    expect(request['X-API-Version']).to eq('2.2')
+
+                    class MockResponse
+                        def initialize
+                        end
+
+                        def code
+                            '200'
+                        end
+
+                        def body
+                            '{
+                                "object": "mock_object",
+                                "id": "' + $test_id + '"
+                            }'
+                        end
+                    end
+
+                    MockResponse.new
+                end
+
+                instance.get($test_id)
+
+                # Restore original version
+                Payload.api_version = original_version
+            end
+        end
+
+        context "when making POST requests" do
+            it "includes X-API-Version header" do
+                $test_id = 'mock_' + rand(9000000...9999999).to_s
+
+                session = Payload::Session.new('test_key', 'https://api.test.com', '2.3')
+                instance = Payload::ARMRequest.new(MockObject, session)
+
+                expect(instance).to receive(:_execute_request) do |http, request|
+                    expect(request.method).to eq("POST")
+                    expect(request['X-API-Version']).to eq('2.3')
+
+                    class MockResponse
+                        def initialize
+                        end
+
+                        def code
+                            '200'
+                        end
+
+                        def body
+                            '{
+                                "object": "mock_object",
+                                "id": "' + $test_id + '"
+                            }'
+                        end
+                    end
+
+                    MockResponse.new
+                end
+
+                instance.create({ field: 'value' })
+            end
+        end
+
+        context "when making PUT requests" do
+            it "includes X-API-Version header" do
+                $test_id = 'mock_' + rand(9000000...9999999).to_s
+
+                session = Payload::Session.new('test_key', 'https://api.test.com', '2.4')
+                instance = Payload::ARMRequest.new(MockObject, session)
+
+                expect(instance).to receive(:_execute_request) do |http, request|
+                    expect(request.method).to eq("PUT")
+                    expect(request['X-API-Version']).to eq('2.4')
+
+                    class MockResponse
+                        def initialize
+                        end
+
+                        def code
+                            '200'
+                        end
+
+                        def body
+                            '{
+                                "object": "mock_object",
+                                "id": "' + $test_id + '"
+                            }'
+                        end
+                    end
+
+                    MockResponse.new
+                end
+
+                instance.update(field: 'new_value')
+            end
+        end
+
+        context "when making DELETE requests" do
+            it "includes X-API-Version header" do
+                $test_id = 'mock_' + rand(9000000...9999999).to_s
+
+                session = Payload::Session.new('test_key', 'https://api.test.com', '2.5')
+
+                # Create mock object to delete
+                mock_obj = MockObject.new({ id: $test_id })
+                mock_obj.set_session(session)
+
+                expect_any_instance_of(Payload::ARMRequest).to receive(:_execute_request) do |inst, http, request|
+                    expect(request.method).to eq("DELETE")
+                    expect(request['X-API-Version']).to eq('2.5')
+
+                    class MockResponse
+                        def initialize
+                        end
+
+                        def code
+                            '200'
+                        end
+
+                        def body
+                            '{
+                                "object": "mock_object",
+                                "id": "' + $test_id + '"
+                            }'
+                        end
+                    end
+
+                    MockResponse.new
+                end
+
+                mock_obj.delete
+            end
+        end
+
+        context "when custom headers are provided" do
+            it "merges X-API-Version header with existing headers" do
+                $test_id = 'mock_' + rand(9000000...9999999).to_s
+
+                session = Payload::Session.new('test_key', 'https://api.test.com', '2.6')
+                instance = Payload::ARMRequest.new(MockObject, session)
+
+                expect(instance).to receive(:_execute_request) do |http, request|
+                    expect(request.method).to eq("POST")
+                    # Verify both Content-Type and X-API-Version headers are present
+                    expect(request['Content-Type']).to eq('application/json')
+                    expect(request['X-API-Version']).to eq('2.6')
+
+                    class MockResponse
+                        def initialize
+                        end
+
+                        def code
+                            '200'
+                        end
+
+                        def body
+                            '{
+                                "object": "mock_object",
+                                "id": "' + $test_id + '"
+                            }'
+                        end
+                    end
+
+                    MockResponse.new
+                end
+
+                instance.create({ field: 'value' })
+            end
+        end
+    end
 end

data/spec/support/helpers/v1_helpers.rb

@@ -0,0 +1,159 @@
+class V1Helpers
+  attr_reader :session
+
+  def initialize(session)
+    @session = session
+  end
+
+  def create_customer_account(name: 'Test', email: 'test@example.com')
+    session.Customer.create(name: name, email: email)
+  end
+
+  def create_processing_account
+    session.ProcessingAccount.create(
+      name: 'Processing Account',
+      legal_entity: {
+        legal_name: 'Test',
+        type: 'INDIVIDUAL_SOLE_PROPRIETORSHIP',
+        ein: '23 423 4234',
+        street_address: '123 Example Street',
+        unit_number: 'Suite 1',
+        city: 'New York',
+        state_province: 'NY',
+        state_incorporated: 'NY',
+        postal_code: '11238',
+        country: 'US',
+        phone_number: '(111) 222-3333',
+        website: 'http://www.payload.com',
+        start_date: '05/01/2015',
+        contact_name: 'Test Person',
+        contact_email: 'test.person@example.com',
+        contact_title: 'VP',
+        owners: [
+          {
+            full_name: 'Test Person',
+            email: 'test.person@example.com',
+            ssn: '234 23 4234',
+            birth_date: '06/20/1985',
+            title: 'CEO',
+            ownership: '100',
+            street_address: '123 Main Street',
+            unit_number: '#1A',
+            city: 'New York',
+            state_province: 'NY',
+            postal_code: '10001',
+            phone_number: '(111) 222-3333',
+            type: 'owner'
+          }
+        ]
+      },
+      payment_methods: [session.PaymentMethod.new(
+        type: 'bank_account',
+        bank_account: {
+          account_number: '123456789',
+          routing_number: '036001808',
+          account_type: 'checking'
+        }
+      )]
+    )
+  end
+
+  def create_card_payment(processing_id, amount: nil, description: nil, customer_id: nil, invoice_id: nil)
+    payment = {
+      processing_id: processing_id,
+      amount: amount || rand * 100,
+      description: description || 'Test Payment',
+      payment_method: session.PaymentMethod.new(
+        type: 'card',
+        card: {
+          card_number: '4242 4242 4242 4242',
+          expiry: '12/35',
+          card_code: '123',
+        },
+        billing_address: {
+          postal_code: '11111'
+        }
+      )
+    }
+    if invoice_id
+      payment = payment.merge({
+        allocations: [{invoice_id: invoice_id}]
+      })
+    end
+    if customer_id
+      payment = payment.merge({
+        customer_id: customer_id
+      })
+    end
+    session.Payment.create(payment)
+  end
+
+  def create_bank_payment
+    session.Payment.create(
+      type: 'payment',
+      amount: rand * 1000,
+      payment_method: session.PaymentMethod.new(
+        type: 'bank_account',
+        account_holder: 'First Last',
+        bank_account: {
+          account_number: '1234567890',
+          routing_number: '036001808',
+          account_type:   'checking'
+        },
+        billing_address: {
+          postal_code: '11111'
+        }
+      )
+    )
+  end
+
+  def create_invoice(processing_account, customer_account)
+    session.Invoice.create(
+      processing_id: processing_account.id,
+      due_date: Date.today.strftime('%Y-%m-%d'),
+      customer_id: customer_account.id,
+      items: [session.ChargeItem.new(amount: 29.99)]
+    )
+  end
+
+  def create_blind_refund(amount, processing_id)
+    session.Refund.create(
+      amount: amount,
+      processing_id: processing_id,
+      payment_method: {
+        type: 'card',
+        card: {
+          card_number: '4242 4242 4242 4242',
+          expiry: '12/30',
+          card_code: '123'
+        },
+        billing_address: { postal_code: '11111' }
+      }
+    )
+  end
+
+  def create_refund(payment, amount: nil)
+    session.Refund.create(
+      amount: amount || payment.amount,
+      ledger: [{assoc_transaction_id: payment.id}]
+    )
+  end
+
+  def create_payment_link_one_time(processing_account)
+    session.PaymentLink.create(
+      type: 'one_time',
+      description: 'Payment Request',
+      amount: 10.00,
+      processing_id: processing_account.id
+    )
+  end
+
+  def create_payment_link_reusable(processing_account)
+    session.PaymentLink.create(
+      type: 'reusable',
+      description: 'Payment Request',
+      amount: 10.00,
+      processing_id: processing_account.id
+    )
+  end
+end

data/spec/support/helpers/v2_helpers.rb

@@ -0,0 +1,205 @@
+class V2Helpers
+  attr_reader :session
+
+  def initialize(session)
+    @session = session
+  end
+
+  def create_customer_account(name: 'Test', email: 'test@example.com')
+    session.Account.create(
+      type: 'customer',
+      name: name,
+      contact_details: {
+        email: email
+      }
+    )
+  end
+
+  def create_processing_account
+    org = session.Profile.all()[0]
+    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: {
+                ownership: {
+                  percentage:  100,
+                  years_owned: 5,
+                },
+                roles: ['principal_officer'],
+                title: 'CEO',
+              },
+            },
+          ],
+        },
+      },
+    )
+  end
+
+  def create_card_payment(processing_id, amount: nil, description: nil, customer_id: nil, invoice_id: nil)
+    sender = {
+      method: session.PaymentMethod.new(
+        type: 'card',
+        card: {
+          card_number: '4242 4242 4242 4242',
+            expiry: '12/35',
+            card_code: '123',
+          },
+        billing_address: {
+          postal_code: '11111'
+        }
+      )
+    }
+    if customer_id
+      sender = sender.merge({
+        account_id: customer_id,
+      })
+    end
+    payment = {
+      type: 'payment',
+      amount: amount || rand * 100,
+      description: description || 'Test Payment',
+      sender: sender,
+    }
+    if invoice_id
+      payment = payment.merge({
+        invoice_allocations: [{invoice_id: invoice_id}]
+      })
+    end
+    if processing_id
+      payment = payment.merge({
+        receiver: {
+          account_id: processing_id,
+        }
+      })
+    end
+    session.Transaction.create(payment)
+  end
+
+  def create_bank_payment
+    session.Transaction.create(
+      type: 'payment',
+      amount: rand * 1000,
+      sender: {
+          method: session.PaymentMethod.new(
+          type: 'bank_account',
+          account_holder: 'First Last',
+          bank_account: {
+            account_number: '123456789',
+            currency:       'USD',
+            routing_number: '036001808',
+            account_type:   'checking',
+            account_class:  'personal',
+          },
+        )
+      }
+    )
+  end
+
+  def create_invoice(processing_account, customer_account)
+    session.Invoice.create(
+      due_date: Date.today.strftime('%Y-%m-%d'),
+      biller: {
+        account_id: processing_account.id,
+      },
+      payer: {
+        account_id: customer_account.id,
+      },
+      items: [
+        {
+          type: 'line_item',
+          line_item: {
+            value: 29.99,
+          }
+        }
+      ],
+    )
+  end
+
+  def create_blind_refund(amount, processing_id)
+    session.Transaction.create(
+      type: 'refund',
+      amount: amount,
+      sender: {
+        account_id: processing_id,
+      },
+      receiver: {
+        method: session.PaymentMethod.new(
+          type: 'card',
+          card: {
+            card_number: '4242 4242 4242 4242',
+            expiry: '12/30',
+            card_code: '123'
+          },
+          billing_address: { postal_code: '11111' }
+        )
+      }
+    )
+  end
+
+  def create_refund(payment, amount: nil)
+    session.Transaction.create(
+      type: 'refund',
+      transfers: [{assoc_transaction_id: payment.id, amount: amount || payment.amount}]
+    )
+  end
+end

data/spec/support/helpers.rb

@@ -0,0 +1,15 @@
+require 'payload'
+require 'date'
+
+RSpec.shared_context 'test helpers' do
+  before(:all) do
+    Payload.api_key = ENV['TEST_SECRET_KEY']
+    if ENV['TEST_API_URL']
+      Payload.api_url = ENV['TEST_API_URL']
+    end
+  end
+end
+
+# Load version-specific helpers
+require_relative 'helpers/v1_helpers'
+require_relative 'helpers/v2_helpers'

data/spec/support/helpers_spec.rb

@@ -0,0 +1,21 @@
+require 'payload'
+require_relative 'helpers'
+
+RSpec.describe 'Test helpers API versions' do
+  include_context 'test helpers'
+
+  describe '#create_processing_account' do
+    [1, 2].each do |api_version|
+      context "api_version=#{api_version}" do
+        let(:session) { Payload::Session.new(Payload.api_key, Payload.api_url, api_version) }
+        let(:h) { Object.const_get("V#{api_version}Helpers").new(session) }
+
+        it 'returns a processing account' do
+          account = h.create_processing_account
+          expect(account).to respond_to(:id)
+        end
+      end
+    end
+  end
+end
+