solidus_afterpay 0.2.0 → 0.3.0

data/spec/models/solidus_afterpay/gateway_spec.rb

@@ -1,492 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe SolidusAfterpay::Gateway do
-  let(:gateway) { described_class.new(options) }
-  let(:options) do
-    {
-      merchant_id: ENV.fetch('AFTERPAY_MERCHANT_ID', 'dummy_merchant_id'),
-      secret_key: ENV.fetch('AFTERPAY_SECRET_KEY', 'dummy_secret_key'),
-      test_mode: true
-    }
-  end
-
-  describe '#authorize' do
-    subject(:response) { gateway.authorize(amount, payment_source, gateway_options) }
-
-    let(:order_token) { '002.m6d9jkrtv1p0j4jqslklhfq9k4nl54jo2530d58kf6snpqq1' }
-    let(:auto_capture) { true }
-    let(:payment_method) { build(:afterpay_payment_method, auto_capture: auto_capture) }
-
-    let(:amount) { 1000 }
-    let(:payment_source) { build(:afterpay_payment_source, token: order_token, payment_method: payment_method) }
-    let(:gateway_options) { {} }
-
-    context 'with the immediate flow' do
-      it 'returns a successful response' do
-        is_expected.to be_success
-      end
-    end
-
-    context 'with the deferred flow' do
-      let(:auto_capture) { false }
-
-      context 'with valid params', vcr: 'deferred/authorize/valid' do
-        it 'authorize the afterpay payment with the order_token' do
-          is_expected.to be_success
-        end
-      end
-
-      context 'with an invalid token', vcr: 'deferred/authorize/invalid' do
-        let(:order_token) { 'INVALID_TOKEN' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Cannot complete payment, expired or invalid token.')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('invalid_token')
-        end
-      end
-
-      context 'with an invalid credit card', vcr: 'deferred/authorize/declined_payment' do
-        let(:order_token) { '002.ijlqnvko1o4ou45uabplrl9pqao8u2v52njs2972r24hje65' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq(
-            'Payment declined. Please contact the Afterpay Customer Service team for more information.'
-          )
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('payment_declined')
-        end
-      end
-
-      context 'with a timeout error' do
-        before do
-          allow(::Afterpay::API::Payment::Auth).to receive(:call).and_raise(
-            ::Afterpay::RequestTimeoutError.new('request_timeout'), 'Request Timeout'
-          )
-          allow(::Afterpay::API::Payment::Reversal).to receive(:call)
-        end
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Request Timeout')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('request_timeout')
-        end
-
-        it 'calls the ::Afterpay::API::Payment::Reversal with order token' do
-          response
-          expect(::Afterpay::API::Payment::Reversal).to have_received(:call).with(token: order_token)
-        end
-      end
-    end
-  end
-
-  describe '#capture' do
-    subject(:response) { gateway.capture(amount, response_code, gateway_options) }
-
-    let(:order_token) { '002.nt7e0ioqj00fh0ua1nbqcj6vcn9obtfsglqvrj9ijpo3edfc' }
-    let(:auto_capture) { true }
-    let(:payment_source) { build(:afterpay_payment_source, token: order_token) }
-    let(:payment_method) { build(:afterpay_payment_method, auto_capture: auto_capture) }
-    let(:payment) { build(:afterpay_payment, source: payment_source, payment_method: payment_method) }
-
-    let(:amount) { 1000 }
-    let(:response_code) { '100101782114' }
-    let(:gateway_options) { { originator: payment, currency: 'USD' } }
-
-    context 'with the immediate flow' do
-      context 'with valid params', vcr: 'immediate/capture/valid' do
-        it 'captures the afterpay payment with the order_token' do
-          is_expected.to be_success
-        end
-      end
-
-      context 'with an invalid token', vcr: 'immediate/capture/invalid' do
-        let(:order_token) { 'INVALID_TOKEN' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Cannot complete payment, expired or invalid token.')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('invalid_token')
-        end
-      end
-
-      context 'with an invalid credit card', vcr: 'immediate/capture/declined_payment' do
-        let(:order_token) { '002.kj16plsn63eqfacueg767cp7l34e9ph5tms4ql14o2iid7l1' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq(
-            'Payment declined. Please contact the Afterpay Customer Service team for more information.'
-          )
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('payment_declined')
-        end
-      end
-    end
-
-    context 'with the deferred flow' do
-      let(:auto_capture) { false }
-
-      context 'with valid params', vcr: 'deferred/capture/valid' do
-        it 'captures the afterpay payment with the order_id' do
-          is_expected.to be_success
-        end
-      end
-
-      context 'with an invalid payment ID', vcr: 'deferred/capture/invalid' do
-        let(:response_code) { 'INVALID_RESPONSE_CODE' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Afterpay payment ID not found.')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('not_found')
-        end
-      end
-
-      context 'with a timeout error' do
-        before do
-          allow(::Afterpay::API::Payment::DeferredCapture).to receive(:call).and_raise(
-            ::Afterpay::RequestTimeoutError.new('request_timeout'), 'Request Timeout'
-          )
-          allow(::Afterpay::API::Payment::Reversal).to receive(:call)
-        end
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Request Timeout')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('request_timeout')
-        end
-
-        it 'calls the ::Afterpay::API::Payment::Reversal with order token' do
-          response
-          expect(::Afterpay::API::Payment::Reversal).to have_received(:call).with(token: order_token)
-        end
-      end
-    end
-  end
-
-  describe '#purchase' do
-    subject(:response) { gateway.purchase(amount, payment_source, gateway_options) }
-
-    let(:order_token) { '002.nt7e0ioqj00fh0ua1nbqcj6vcn9obtfsglqvrj9ijpo3edfc' }
-    let(:auto_capture) { true }
-    let(:payment_method) { build(:afterpay_payment_method, auto_capture: auto_capture) }
-    let(:payment) { build(:afterpay_payment, source: payment_source, payment_method: payment_method) }
-
-    let(:amount) { 1000 }
-    let(:payment_source) { build(:afterpay_payment_source, token: order_token, payment_method: payment_method) }
-    let(:gateway_options) { { originator: payment, currency: 'USD' } }
-
-    context 'with the immediate flow' do
-      context 'with valid params', vcr: 'immediate/capture/valid' do
-        it 'authorize and captures the afterpay payment with the order_token' do
-          is_expected.to be_success
-        end
-      end
-
-      context 'with an invalid token', vcr: 'immediate/capture/invalid' do
-        let(:order_token) { 'INVALID_TOKEN' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Cannot complete payment, expired or invalid token.')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('invalid_token')
-        end
-      end
-
-      context 'with an invalid credit card', vcr: 'immediate/capture/declined_payment' do
-        let(:order_token) { '002.kj16plsn63eqfacueg767cp7l34e9ph5tms4ql14o2iid7l1' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq(
-            'Payment declined. Please contact the Afterpay Customer Service team for more information.'
-          )
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('payment_declined')
-        end
-      end
-    end
-
-    context 'with the deferred flow' do
-      let(:auto_capture) { false }
-
-      context 'with valid params', vcr: 'deferred/authorize/valid' do
-        it 'authorize and captures the afterpay payment with the order_token' do
-          VCR.use_cassette('deferred/capture/valid') do
-            is_expected.to be_success
-          end
-        end
-      end
-
-      context 'with an invalid token', vcr: 'deferred/authorize/invalid' do
-        let(:order_token) { 'INVALID_TOKEN' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Cannot complete payment, expired or invalid token.')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('invalid_token')
-        end
-      end
-
-      context 'with an invalid credit card', vcr: 'deferred/authorize/declined_payment' do
-        let(:order_token) { '002.kj16plsn63eqfacueg767cp7l34e9ph5tms4ql14o2iid7l1' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq(
-            'Payment declined. Please contact the Afterpay Customer Service team for more information.'
-          )
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('payment_declined')
-        end
-      end
-    end
-  end
-
-  describe '#credit' do
-    subject(:response) { gateway.credit(amount, response_code, gateway_options) }
-
-    let(:payment) { build(:afterpay_payment) }
-    let(:refund) { build(:refund, payment: payment) }
-
-    let(:amount) { 1000 }
-    let(:response_code) { '100101768366' }
-    let(:gateway_options) { { originator: refund } }
-
-    context 'with valid params', vcr: 'credit/valid' do
-      it 'refunds the amount using the response_code' do
-        is_expected.to be_success
-      end
-    end
-
-    context 'with an invalid response_code', vcr: 'credit/invalid' do
-      let(:response_code) { 'INVALID_RESPONSE_CODE' }
-
-      it 'returns an unsuccesfull response' do
-        is_expected.not_to be_success
-      end
-
-      it 'returns the error message from Afterpay in the response' do
-        expect(response.message).to eq('Afterpay payment ID not found.')
-      end
-
-      it 'returns the error_code from Afterpay in the response' do
-        expect(response.error_code).to eq('not_found')
-      end
-    end
-  end
-
-  describe '#void' do
-    subject(:response) { gateway.void(response_code, gateway_options) }
-
-    let(:auto_capture) { true }
-    let(:amount) { 10 }
-    let(:payment_method) { build(:afterpay_payment_method, auto_capture: auto_capture) }
-    let(:payment) { build(:afterpay_payment, payment_method: payment_method, amount: amount) }
-
-    let(:response_code) { '100101785223' }
-    let(:gateway_options) { { originator: payment, currency: 'USD' } }
-
-    context 'with the immediate flow' do
-      it 'returns an unsuccessful response' do
-        is_expected.not_to be_success
-      end
-
-      it 'returns the error message from Afterpay in the response' do
-        expect(response.message).to eq("Transaction can't be voided")
-      end
-
-      it 'returns the error_code from Afterpay in the response' do
-        expect(response.error_code).to eq('void_not_allowed')
-      end
-    end
-
-    context 'with the deferred flow' do
-      let(:auto_capture) { false }
-
-      context 'with valid params', vcr: 'deferred/void/valid' do
-        it 'voids the payment using the response_code' do
-          is_expected.to be_success
-        end
-      end
-
-      context 'with an invalid response_code', vcr: 'deferred/void/invalid' do
-        let(:response_code) { 'INVALID_RESPONSE_CODE' }
-
-        it 'returns an unsuccesfull response' do
-          is_expected.not_to be_success
-        end
-
-        it 'returns the error message from Afterpay in the response' do
-          expect(response.message).to eq('Afterpay payment ID not found.')
-        end
-
-        it 'returns the error_code from Afterpay in the response' do
-          expect(response.error_code).to eq('not_found')
-        end
-      end
-    end
-  end
-
-  describe '#create_checkout' do
-    subject(:response) { gateway.create_checkout(order, gateway_options) }
-
-    let(:redirect_confirm_url) { 'https://merchantsite.com/confirm' }
-    let(:redirect_cancel_url) { 'https://merchantsite.com/cancel' }
-
-    let(:order) { build(:order_with_line_items) }
-    let(:gateway_options) { { redirect_confirm_url: redirect_confirm_url, redirect_cancel_url: redirect_cancel_url } }
-
-    context 'with valid params', vcr: 'create_checkout/valid' do
-      it 'creates the checkout' do
-        is_expected.to be_success
-      end
-
-      it 'returns the order_token' do
-        expect(response.params).to include('token')
-      end
-    end
-
-    context 'with an invalid params', vcr: 'create_checkout/invalid' do
-      let(:redirect_confirm_url) { 'INVALID_URL' }
-
-      it 'returns an unsuccesfull response' do
-        is_expected.not_to be_success
-      end
-
-      it 'returns the error message from Afterpay in the response' do
-        expect(response.message).to eq('merchant.redirectConfirmUrl must be a valid URL')
-      end
-
-      it 'returns the error_code from Afterpay in the response' do
-        expect(response.error_code).to eq('invalid_object')
-      end
-    end
-  end
-
-  describe '#find_payment' do
-    subject(:response) { gateway.find_payment(order_id: order_id) }
-
-    let(:order_id) { '100101785223' }
-
-    context 'with valid params', vcr: 'find_payment/valid' do
-      it 'retrieves the Afterpay payment' do
-        expect(response).to include('id' => order_id)
-      end
-    end
-
-    context 'with an invalid params', vcr: 'find_payment/invalid' do
-      let(:order_id) { 'INVALID_ORDER_ID' }
-
-      it 'returns nil' do
-        is_expected.to be_nil
-      end
-    end
-  end
-
-  describe '#find_order' do
-    subject(:response) { gateway.find_order(token: token) }
-
-    let(:token) { '002.cb9qevbs1o4el3adh817hqkotkbv4b8u1jkekofd3nb2m8lu' }
-
-    context 'with valid params', vcr: 'find_order/valid' do
-      it 'retrieves the Afterpay order' do
-        expect(response).to include(token: token)
-      end
-    end
-
-    context 'with an invalid params', vcr: 'find_order/invalid' do
-      let(:token) { 'INVALID_TOKEN' }
-
-      it 'returns nil' do
-        is_expected.to be_nil
-      end
-    end
-  end
-
-  describe '#retrieve_configuration' do
-    subject(:response) { gateway.retrieve_configuration }
-
-    context 'with valid response', vcr: 'retrieve_configuration/valid' do
-      it 'retrieves the afterpay configuration' do
-        expect(response).to include('minimumAmount', 'maximumAmount')
-      end
-    end
-
-    context 'with invalid response' do
-      before do
-        allow(::Afterpay::API::Configuration::Retrieve).to receive(:call).and_raise(::Afterpay::BaseError.new(nil))
-      end
-
-      it 'retrieves the afterpay configuration' do
-        expect(response).to be_nil
-      end
-    end
-  end
-end

data/spec/models/solidus_afterpay/order_component_builder_spec.rb

@@ -1,198 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe SolidusAfterpay::OrderComponentBuilder do
-  let(:order) { create(:order_with_product_property) }
-  let(:redirect_confirm_url) { 'https://merchantsite.com/confirm' }
-  let(:redirect_cancel_url) { 'https://merchantsite.com/cancel' }
-
-  let(:builder) do
-    described_class.new(
-      order: order,
-      redirect_confirm_url: redirect_confirm_url,
-      redirect_cancel_url: redirect_cancel_url,
-      mode: nil,
-      popup_origin_url: nil
-    )
-  end
-
-  describe '#call' do
-    subject(:result) { builder.call }
-
-    let(:expected_result_not_combined) do
-      Afterpay::Components::Order.new(
-        amount: Afterpay::Components::Money.new(amount: '110.0', currency: 'USD'),
-        billing: Afterpay::Components::Contact.new(
-          area1: 'Herndon',
-          area2: nil,
-          country_code: nil,
-          line1: 'PO Box 1337',
-          line2: 'Northwest',
-          name: 'John',
-          phone_number: '555-555-0199',
-          postcode: order.billing_address.zipcode,
-          region: 'AL'
-        ),
-        consumer: Afterpay::Components::Consumer.new(
-          email: order.user.email,
-          given_names: 'John',
-          phone_number: nil,
-          surname: nil
-        ),
-        courier: nil,
-        discounts: nil,
-        items: [
-          Afterpay::Components::Item.new(
-            preorder: true,
-            estimated_shipment_date: "2025-10-25",
-            name: order.line_items.first.name,
-            price: Afterpay::Components::Money.new(
-              amount: '10.0',
-              currency: 'USD'
-            ),
-            quantity: 1,
-            sku: order.line_items.first.sku
-          )
-        ],
-        merchant: Afterpay::Components::Merchant.new(
-          redirect_confirm_url: 'https://merchantsite.com/confirm',
-          redirect_cancel_url: 'https://merchantsite.com/cancel'
-        ),
-        merchant_reference: order.number,
-        payment_type: nil,
-        shipping: Afterpay::Components::Contact.new(
-          area1: 'Herndon',
-          area2: nil,
-          country_code: nil,
-          line1: 'A Different Road',
-          line2: 'Northwest',
-          name: 'John',
-          phone_number: '555-555-0199',
-          postcode: order.shipping_address.zipcode,
-          region: 'AL'
-        ),
-        shipping_amount: nil,
-        tax_amount: nil
-      )
-    end
-
-    let(:expected_result_combined) do
-      Afterpay::Components::Order.new(
-        amount: Afterpay::Components::Money.new(amount: '110.0', currency: 'USD'),
-        billing: Afterpay::Components::Contact.new(
-          area1: 'Herndon',
-          area2: nil,
-          country_code: nil,
-          line1: 'PO Box 1337',
-          line2: 'Northwest',
-          name: 'John Von Doe',
-          phone_number: '555-555-0199',
-          postcode: order.billing_address.zipcode,
-          region: 'AL'
-        ),
-        consumer: Afterpay::Components::Consumer.new(
-          email: order.user.email,
-          given_names: 'John',
-          phone_number: nil,
-          surname: 'Von Doe'
-        ),
-        courier: nil,
-        discounts: nil,
-        items: [
-          Afterpay::Components::Item.new(
-            estimated_shipment_date: "2025-10-25",
-            preorder: true,
-            name: order.line_items.first.name,
-            price: Afterpay::Components::Money.new(
-              amount: '10.0',
-              currency: 'USD'
-            ),
-            quantity: 1,
-            sku: order.line_items.first.sku
-          )
-        ],
-        merchant: Afterpay::Components::Merchant.new(
-          redirect_confirm_url: 'https://merchantsite.com/confirm',
-          redirect_cancel_url: 'https://merchantsite.com/cancel'
-        ),
-        merchant_reference: order.number,
-        payment_type: nil,
-        shipping: Afterpay::Components::Contact.new(
-          area1: 'Herndon',
-          area2: nil,
-          country_code: nil,
-          line1: 'A Different Road',
-          line2: 'Northwest',
-          name: 'John Von Doe',
-          phone_number: '555-555-0199',
-          postcode: order.shipping_address.zipcode,
-          region: 'AL'
-        ),
-        shipping_amount: nil,
-        tax_amount: nil
-      )
-    end
-
-    context 'when solidus combines first and last name' do
-      before do
-        allow(SolidusSupport)
-          .to receive(:combined_first_and_last_name_in_address?)
-          .and_return(true)
-      end
-
-      it 'returns the correct payload' do
-        expect(result.as_json).to eq(expected_result_combined.as_json)
-      end
-    end
-
-    context 'when solidus does not combine first and last name' do
-      before do
-        allow(SolidusSupport)
-          .to receive(:combined_first_and_last_name_in_address?)
-          .and_return(false)
-
-        # rubocop:disable RSpec/AnyInstance
-        allow_any_instance_of(Spree::Address)
-          .to receive(:first_name)
-          .and_return('John')
-
-        allow_any_instance_of(Spree::Address)
-          .to receive(:last_name)
-          .and_return(nil)
-        # rubocop:enable RSpec/AnyInstance
-      end
-
-      it 'returns the correct payload' do
-        expect(result.as_json).to eq(expected_result_not_combined.as_json)
-      end
-    end
-
-    context "when provided an estimated shipment date" do
-      context "when provided a product estimated shipment date" do
-        it "returns the correct estimated shipment date" do
-          expect(result.items.first.estimated_shipment_date).to match("2025-10-25")
-        end
-
-        it "returns true if the estimated shipping date didn't pass yet" do
-          expect(result.items.first.preorder).to be_truthy
-        end
-      end
-
-      context "when provided a variant estimated shipment date" do
-        let(:order) { create(:order_with_variant_property) }
-
-        it 'contains the correct estimated shipment date' do
-          expect(result.items.first.estimated_shipment_date).to match("2021-09-19")
-        end
-
-        it 'returns the variant estimated shipment date when product and variant properties are set' do
-          order.line_items.first.product.set_property("estimatedShipmentDate", "2025-10-25")
-          expect(result.items.first.estimated_shipment_date).to match("2021-09-19")
-        end
-
-        it "returns false when the estimated shipping date passed" do
-          expect(result.items.first.preorder).to be_falsey
-        end
-      end
-    end
-  end
-end