payload-api 0.4.1 → 0.6.0

data/spec/payload/arm/request_spec.rb

@@ -11,7 +11,7 @@ RSpec.describe Payload::ARMRequest do
 
         context "when the user selects custom fields" do
             it "selects the requested fields" do
-                instance.select(' name', 'age  ')
+                instance.select('name', 'age')
                 expect(instance.instance_variable_get(:@filters)).to eq({ "fields" => "name,age" })
                 instance.select('count(id)', 'sum(amount)')
                 expect(instance.instance_variable_get(:@filters)).to eq({ "fields" => "count(id),sum(amount)" })
@@ -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/payload/arm/session_spec.rb

@@ -24,6 +24,46 @@ RSpec.describe Payload::Session do
         end
     end
 
+    describe "#attr" do
+        it "returns an AttrRoot so pl.attr.name returns an Attr (not shadowed by Class#name)" do
+            instance = described_class.new("test_key", "https://api.hello.co")
+            root = instance.attr
+
+            expect(root).to be_a(Payload::AttrRoot)
+            expect(root.id).to be_a(Payload::Attr)
+            expect(root.id.to_s).to eq("id")
+
+            expect(root.created_at(:year)).to be_a(Payload::Attr)
+            expect(root.created_at(:year).to_s).to eq("year(created_at)")
+
+            expect(root.created_at.year.to_s).to eq("created_at[year]")
+        end
+    end
+
+    describe "query chaining with session" do
+        it "passes session through query -> select -> order_by -> limit chain" do
+            instance = described_class.new("session_key", "https://api.test.com", "v2")
+            req = instance.query(Payload::Invoice).select("id", "amount").order_by("created_at").limit(5)
+
+            expect(req).to be_a(Payload::ARMRequest)
+            expect(req.instance_variable_get(:@session)).to eq(instance)
+            expect(req.instance_variable_get(:@filters)["fields"]).to eq("id,amount")
+            expect(req.instance_variable_get(:@order_by)).to include("created_at")
+            expect(req.instance_variable_get(:@limit)).to eq(5)
+        end
+
+        it "filter_by with session.attr uses AttrRoot from same session" do
+            instance = described_class.new("test_key", "https://api.test.com", "v2")
+            filter_expr = instance.attr.status == "processed"
+            req = instance.query(Payload::Transaction).filter_by(filter_expr)
+
+            expect(req.instance_variable_get(:@session)).to eq(instance)
+            expect(req.instance_variable_get(:@filter_objects)).to include(be_a(Payload::ARMEqual))
+            params = req.request_params
+            expect(params["status"]).to eq("processed")
+        end
+    end
+
     describe "#query" do
 
         context "when the user queries an ARMObject with a session" do

data/spec/payload/exceptions_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "payload"
+
+RSpec.describe Payload::TransactionDeclined do
+  def api_error_payload(message:, details: nil)
+    {
+      "object" => "error",
+      "error_type" => "TransactionDeclined",
+      "error_description" => message,
+      "details" => details,
+    }.compact
+  end
+
+  it "inherits from BadRequest (HTTP 400)" do
+    expect(described_class.superclass).to eq(Payload::BadRequest)
+    expect(Payload::BadRequest.code).to eq("400")
+  end
+
+  it "sets message from first argument (same as request.rb: data['error_description'])" do
+    e = described_class.new("Card declined", nil)
+    expect(e.message).to eq("Card declined")
+  end
+
+  it "exposes #transaction as nil when data is nil" do
+    e = described_class.new("Declined", nil)
+    expect(e.transaction).to be_nil
+  end
+
+  it "exposes #transaction as nil when details is missing" do
+    e = described_class.new("Declined", api_error_payload(message: "Declined"))
+    expect(e.transaction).to be_nil
+  end
+
+  it "exposes #transaction as nil when details is not a Hash" do
+    e = described_class.new("Declined", api_error_payload(message: "Declined", details: "string"))
+    expect(e.transaction).to be_nil
+  end
+
+  it "builds a transaction object from data['details'] when present (API-realistic payload)" do
+    details = {
+      "id" => "txn_123",
+      "object" => "transaction",
+      "type" => "payment",
+      "status" => "declined",
+      "status_code" => "do_not_honor",
+      "amount" => 100.0,
+    }
+    data = api_error_payload(message: "Transaction was declined", details: details)
+    e = described_class.new(data["error_description"], data)
+
+    expect(e.transaction).to be_a(Payload::ARMObject)
+    expect(e.transaction.id).to eq("txn_123")
+    expect(e.transaction["status"]).to eq("declined")
+    expect(e.transaction["status_code"]).to eq("do_not_honor")
+    expect(e.transaction["amount"]).to eq(100.0)
+    expect(e.transaction).to be_a(Payload::Payment)
+  end
+
+  it "uses Transaction when get_cls returns nil for details (minimal details, no object key)" do
+    details = { "id" => "txn_456", "status" => "declined" }
+    data = api_error_payload(message: "Declined", details: details)
+    e = described_class.new(data["error_description"], data)
+
+    expect(e.transaction).to be_a(Payload::Transaction)
+    expect(e.transaction.id).to eq("txn_456")
+  end
+
+  it "matches how ARM request raises: message from error_description, data = full response" do
+    data = {
+      "object" => "error",
+      "error_type" => "TransactionDeclined",
+      "error_description" => "There was an issue processing the payment",
+      "details" => { "id" => "txn_789", "object" => "transaction", "status" => "declined" },
+    }
+    e = described_class.new(data["error_description"], data)
+
+    expect(e.message).to eq("There was an issue processing the payment")
+    expect(e.transaction).to be_a(Payload::ARMObject)
+    expect(e.transaction.id).to eq("txn_789")
+  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