solidus_afterpay 0.1.0

data/spec/models/solidus_afterpay/order_component_builder_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+RSpec.describe SolidusAfterpay::OrderComponentBuilder do
+  let(:order) { build(:order_with_line_items) }
+  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
+    )
+  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(
+            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(
+            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
+
+    let(:expected_result) do
+      SolidusSupport.combined_first_and_last_name_in_address? ? expected_result_combined : expected_result_not_combined
+    end
+
+    it 'returns the correct payload' do
+      expect(result.as_json).to eq(expected_result.as_json)
+    end
+  end
+end

data/spec/models/solidus_afterpay/payment_method_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+RSpec.describe SolidusAfterpay::PaymentMethod, type: :model do
+  let(:payment_method) { described_class.new }
+
+  describe "#gateway_class" do
+    subject { payment_method.gateway_class }
+
+    it { is_expected.to eq(SolidusAfterpay::Gateway) }
+  end
+
+  describe "#payment_source_class" do
+    subject { payment_method.payment_source_class }
+
+    it { is_expected.to eq(SolidusAfterpay::PaymentSource) }
+  end
+
+  describe "#partial_name" do
+    subject { payment_method.partial_name }
+
+    it { is_expected.to eq('afterpay') }
+  end
+
+  describe "#try_void" do
+    subject { payment_method.try_void(payment) }
+
+    let(:response_code) { 'RESPONSE_CODE' }
+    let(:payment_source) { build(:afterpay_payment_source) }
+    let(:payment) { build(:afterpay_payment, response_code: response_code, source: payment_source) }
+
+    let(:can_void?) { true }
+    let(:gateway_response_success?) { true }
+    let(:gateway_response) { ActiveMerchant::Billing::Response.new(gateway_response_success?, '') }
+
+    let(:gateway_options) { { originator: payment, currency: 'USD' } }
+
+    before do
+      allow(payment_source).to receive(:can_void?).and_return(can_void?)
+      allow(payment_method).to receive(:void).with(response_code, gateway_options).and_return(gateway_response)
+    end
+
+    context 'when the void completes successful' do
+      it 'returns the void response' do
+        is_expected.to eq(gateway_response)
+      end
+    end
+
+    context 'when the void throws an error' do
+      let(:gateway_response_success?) { false }
+
+      it { is_expected.to be(false) }
+    end
+
+    context "when the payment can't be voided" do
+      let(:can_void?) { false }
+
+      it { is_expected.to be(false) }
+    end
+  end
+
+  describe "#available_for_order?" do
+    subject { payment_method.available_for_order?(order) }
+
+    let(:preferred_minimum_amount) { nil }
+    let(:preferred_maximum_amount) { nil }
+    let(:preferred_currency) { nil }
+
+    let(:payment_method) do
+      described_class.new(
+        preferred_minimum_amount: preferred_minimum_amount,
+        preferred_maximum_amount: preferred_maximum_amount,
+        preferred_currency: preferred_currency
+      )
+    end
+
+    let(:order) { build(:order, currency: order_currency, total: order_total) }
+    let(:order_total) { 5 }
+    let(:order_currency) { 'USD' }
+
+    let(:configuration) do
+      require 'hashie'
+
+      Hashie::Mash.new({
+        minimumAmount: { amount: '1', currency: 'USD' },
+        maximumAmount: { amount: '10', currency: 'USD' }
+      })
+    end
+
+    before do
+      allow(payment_method.gateway).to receive(:retrieve_configuration).and_return(configuration)
+    end
+
+    context 'when preference settings are nil' do
+      context 'when order total is inside the range' do
+        it { is_expected.to be(true) }
+      end
+
+      context 'when order total is outside the range' do
+        let(:order_total) { 11 }
+
+        it { is_expected.to be(false) }
+      end
+
+      context 'when order currency is different from afterpay configuration' do
+        let(:order_currency) { 'EUR' }
+
+        it { is_expected.to be(false) }
+      end
+
+      context "when afterpay configuration doesn't include the minumumAmount" do
+        let(:configuration) do
+          require 'hashie'
+
+          Hashie::Mash.new({ maximumAmount: { amount: '10', currency: 'USD' } })
+        end
+
+        it { is_expected.to be(true) }
+      end
+    end
+
+    context 'when preference settings are not nil' do
+      let(:preferred_minimum_amount) { 1 }
+      let(:preferred_maximum_amount) { 10 }
+      let(:preferred_currency) { 'USD' }
+
+      context 'when order total is inside the range' do
+        it { is_expected.to be(true) }
+      end
+
+      context 'when order total is outside the range' do
+        let(:order_total) { 11 }
+
+        it { is_expected.to be(false) }
+      end
+
+      context 'when order currency is different from afterpay configuration' do
+        let(:order_currency) { 'EUR' }
+
+        it { is_expected.to be(false) }
+      end
+    end
+  end
+end

data/spec/models/solidus_afterpay/payment_source_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+RSpec.describe SolidusAfterpay::PaymentSource, type: :model do
+  let(:payment_source) { described_class.new }
+
+  describe '#actions' do
+    subject { payment_source.actions }
+
+    it 'supports capture, void, and credit' do
+      is_expected.to eq(%w[capture void credit])
+    end
+  end
+
+  describe '#can_void?' do
+    subject { payment_source.can_void?(payment) }
+
+    let(:deferred?) { false }
+    let(:payment_method) { build(:afterpay_payment_method, preferred_deferred: deferred?) }
+    let(:payment) { build(:afterpay_payment, payment_method: payment_method) }
+
+    context 'with the immediate flow' do
+      it 'is always false' do
+        is_expected.to be(false)
+      end
+    end
+
+    context 'with the deferred flow' do
+      let(:deferred?) { true }
+
+      let(:payment_state) { 'AUTH_APPROVED' }
+      let(:gateway_response) { { paymentState: payment_state } }
+      let(:gateway) { instance_double(SolidusAfterpay::Gateway, find_payment: gateway_response) }
+
+      before do
+        allow(payment_method).to receive(:gateway).and_return(gateway)
+      end
+
+      context 'when the payment exists and the payment state is voidable' do
+        it 'returns true' do
+          is_expected.to be(true)
+        end
+      end
+
+      context 'when the payment exists when the payment state is not voidable' do
+        let(:payment_state) { 'NOT_VOIDABLE' }
+
+        it 'returns false' do
+          is_expected.to be(false)
+        end
+      end
+
+      context "when the payment doesn't exist" do
+        let(:gateway_response) { nil }
+
+        it 'returns false' do
+          is_expected.to be(false)
+        end
+      end
+    end
+  end
+end

data/spec/models/solidus_afterpay/user_agent_generator_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+RSpec.describe SolidusAfterpay::UserAgentGenerator do
+  describe '#generate' do
+    subject { user_agent_generator.generate }
+
+    let(:user_agent_generator) { described_class.new(merchant_id: merchant_id) }
+    let(:merchant_id) { 'MERCHANT_ID' }
+    let(:default_store) { build(:store, url: 'test.com') }
+
+    before do
+      stub_const('SolidusAfterpay::VERSION', '0.1.0')
+      allow(::Spree).to receive(:solidus_gem_version).and_return('3.0.1')
+      stub_const('RUBY_VERSION', '2.6.6')
+      allow(::Spree::Store).to receive(:default).and_return(default_store)
+    end
+
+    it 'includes the production javascript' do
+      is_expected.to eq('SolidusAfterpay/0.1.0 (Solidus/3.0.1; Ruby/2.6.6; Merchant/MERCHANT_ID) https://test.com')
+    end
+  end
+end

data/spec/models/spree/order_spec.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Spree::Order, type: :model do
+  let(:store) { create(:store) }
+  let(:user) { create(:user, email: "solidus@example.com") }
+  let(:order) { create(:order, user: user, store: store) }
+
+  describe "#available_payment_methods" do
+    it "includes frontend payment methods" do
+      payment_method = Spree::PaymentMethod::Check.create!({
+        name: "Fake",
+        active: true,
+        available_to_users: true,
+        available_to_admin: false
+      })
+      expect(order.available_payment_methods).to include(payment_method)
+    end
+
+    it "includes 'both' payment methods" do
+      payment_method = Spree::PaymentMethod::Check.create!({
+        name: "Fake",
+        active: true,
+        available_to_users: true,
+        available_to_admin: true
+      })
+      expect(order.available_payment_methods).to include(payment_method)
+    end
+
+    # rubocop:disable RSpec/MultipleExpectations
+    it "does not include a payment method twice" do
+      payment_method = Spree::PaymentMethod::Check.create!({
+        name: "Fake",
+        active: true,
+        available_to_users: true,
+        available_to_admin: true
+      })
+      expect(order.available_payment_methods.count).to eq(1)
+      expect(order.available_payment_methods).to include(payment_method)
+    end
+    # rubocop:enable RSpec/MultipleExpectations
+
+    it "does not include inactive payment methods" do
+      Spree::PaymentMethod::Check.create!({
+        name: "Fake",
+        active: false,
+        available_to_users: true,
+        available_to_admin: true
+      })
+      expect(order.available_payment_methods.count).to eq(0)
+    end
+
+    context "with more than one payment method" do
+      subject { order.available_payment_methods }
+
+      let!(:first_method) {
+        FactoryBot.create(:payment_method, available_to_users: true,
+                                               available_to_admin: true)
+      }
+      let!(:second_method) {
+        FactoryBot.create(:payment_method, available_to_users: true,
+                                               available_to_admin: true)
+      }
+
+      before do
+        second_method.move_to_top
+      end
+
+      it "respects the order of methods based on position" do
+        is_expected.to eq([second_method, first_method])
+      end
+
+      context 'when a payment method responds to #available_for_order?' do
+        let(:third_method) {
+          FakePaymentMethod.create(name: 'Fake', available_to_users: true, available_to_admin: true)
+        }
+
+        before do
+          fake_payment_method_class = Class.new(SolidusSupport.payment_method_parent_class)
+          stub_const('FakePaymentMethod', fake_payment_method_class)
+
+          third_method
+        end
+
+        context 'when it responds with true' do
+          before do
+            FakePaymentMethod.class_eval { def available_for_order?(_order); true; end }
+          end
+
+          it 'includes it in the result' do
+            is_expected.to eq([second_method, first_method, third_method])
+          end
+        end
+
+        context 'when it responds with false' do
+          before do
+            FakePaymentMethod.class_eval { def available_for_order?(_order); false; end }
+          end
+
+          it "doesn't include it in the result" do
+            is_expected.to eq([second_method, first_method])
+          end
+        end
+      end
+    end
+
+    context 'when the order has a store' do
+      let(:order) { create(:order) }
+
+      let!(:store_with_payment_methods) do
+        create(:store,
+          payment_methods: [payment_method_with_store])
+      end
+      let!(:payment_method_with_store) { create(:payment_method) }
+      let!(:store_without_payment_methods) { create(:store) }
+      let!(:payment_method_without_store) { create(:payment_method) }
+
+      context 'when the store has payment methods' do
+        before { order.update!(store: store_with_payment_methods) }
+
+        it 'returns only the matching payment methods for that store' do
+          expect(order.available_payment_methods).to match_array(
+            [payment_method_with_store]
+          )
+        end
+
+        context 'when the store has an extra payment method unavailable to users' do
+          let!(:admin_only_payment_method) do
+            create(:payment_method,
+              available_to_users: false,
+              available_to_admin: true)
+          end
+
+          before do
+            store_with_payment_methods.payment_methods << admin_only_payment_method
+          end
+
+          it 'returns only the payment methods available to users for that store' do
+            expect(order.available_payment_methods).to match_array(
+              [payment_method_with_store]
+            )
+          end
+        end
+      end
+
+      context 'when the store does not have payment methods' do
+        before { order.update!(store: store_without_payment_methods) }
+
+        it 'returns all matching payment methods regardless of store' do
+          expect(order.available_payment_methods).to match_array(
+            [payment_method_with_store, payment_method_without_store]
+          )
+        end
+      end
+    end
+  end
+end