solidus_afterpay 0.1.0 → 0.2.0

data/spec/models/solidus_afterpay/gateway_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe SolidusAfterpay::Gateway do
@@ -14,8 +16,8 @@ RSpec.describe SolidusAfterpay::Gateway do
     subject(:response) { gateway.authorize(amount, payment_source, gateway_options) }
 
     let(:order_token) { '002.m6d9jkrtv1p0j4jqslklhfq9k4nl54jo2530d58kf6snpqq1' }
-    let(:deferred?) { false }
-    let(:payment_method) { build(:afterpay_payment_method, preferred_deferred: deferred?) }
+    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) }
@@ -28,7 +30,7 @@ RSpec.describe SolidusAfterpay::Gateway do
     end
 
     context 'with the deferred flow' do
-      let(:deferred?) { true }
+      let(:auto_capture) { false }
 
       context 'with valid params', vcr: 'deferred/authorize/valid' do
         it 'authorize the afterpay payment with the order_token' do
@@ -69,6 +71,32 @@ RSpec.describe SolidusAfterpay::Gateway 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
 
@@ -76,9 +104,9 @@ RSpec.describe SolidusAfterpay::Gateway do
     subject(:response) { gateway.capture(amount, response_code, gateway_options) }
 
     let(:order_token) { '002.nt7e0ioqj00fh0ua1nbqcj6vcn9obtfsglqvrj9ijpo3edfc' }
-    let(:deferred?) { false }
+    let(:auto_capture) { true }
     let(:payment_source) { build(:afterpay_payment_source, token: order_token) }
-    let(:payment_method) { build(:afterpay_payment_method, preferred_deferred: deferred?) }
+    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 }
@@ -128,7 +156,7 @@ RSpec.describe SolidusAfterpay::Gateway do
     end
 
     context 'with the deferred flow' do
-      let(:deferred?) { true }
+      let(:auto_capture) { false }
 
       context 'with valid params', vcr: 'deferred/capture/valid' do
         it 'captures the afterpay payment with the order_id' do
@@ -151,6 +179,32 @@ RSpec.describe SolidusAfterpay::Gateway 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
 
@@ -158,8 +212,8 @@ RSpec.describe SolidusAfterpay::Gateway do
     subject(:response) { gateway.purchase(amount, payment_source, gateway_options) }
 
     let(:order_token) { '002.nt7e0ioqj00fh0ua1nbqcj6vcn9obtfsglqvrj9ijpo3edfc' }
-    let(:deferred?) { false }
-    let(:payment_method) { build(:afterpay_payment_method, preferred_deferred: deferred?) }
+    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 }
@@ -209,7 +263,7 @@ RSpec.describe SolidusAfterpay::Gateway do
     end
 
     context 'with the deferred flow' do
-      let(:deferred?) { true }
+      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
@@ -291,9 +345,9 @@ RSpec.describe SolidusAfterpay::Gateway do
   describe '#void' do
     subject(:response) { gateway.void(response_code, gateway_options) }
 
-    let(:deferred?) { false }
+    let(:auto_capture) { true }
     let(:amount) { 10 }
-    let(:payment_method) { build(:afterpay_payment_method, preferred_deferred: deferred?) }
+    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' }
@@ -314,7 +368,7 @@ RSpec.describe SolidusAfterpay::Gateway do
     end
 
     context 'with the deferred flow' do
-      let(:deferred?) { true }
+      let(:auto_capture) { false }
 
       context 'with valid params', vcr: 'deferred/void/valid' do
         it 'voids the payment using the response_code' do
@@ -396,6 +450,26 @@ RSpec.describe SolidusAfterpay::Gateway do
     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 }
 

data/spec/models/solidus_afterpay/order_component_builder_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 RSpec.describe SolidusAfterpay::OrderComponentBuilder do
-  let(:order) { build(:order_with_line_items) }
+  let(:order) { create(:order_with_product_property) }
   let(:redirect_confirm_url) { 'https://merchantsite.com/confirm' }
   let(:redirect_cancel_url) { 'https://merchantsite.com/cancel' }
 
@@ -9,7 +9,9 @@ RSpec.describe SolidusAfterpay::OrderComponentBuilder do
     described_class.new(
       order: order,
       redirect_confirm_url: redirect_confirm_url,
-      redirect_cancel_url: redirect_cancel_url
+      redirect_cancel_url: redirect_cancel_url,
+      mode: nil,
+      popup_origin_url: nil
     )
   end
 
@@ -40,6 +42,8 @@ RSpec.describe SolidusAfterpay::OrderComponentBuilder do
         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',
@@ -95,6 +99,8 @@ RSpec.describe SolidusAfterpay::OrderComponentBuilder do
         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',
@@ -126,12 +132,67 @@ RSpec.describe SolidusAfterpay::OrderComponentBuilder do
       )
     end
 
-    let(:expected_result) do
-      SolidusSupport.combined_first_and_last_name_in_address? ? expected_result_combined : expected_result_not_combined
+    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
 
-    it 'returns the correct payload' do
-      expect(result.as_json).to eq(expected_result.as_json)
+    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

data/spec/models/solidus_afterpay/payment_method_spec.rb

@@ -58,79 +58,104 @@ RSpec.describe SolidusAfterpay::PaymentMethod, type: :model do
     end
   end
 
-  describe "#available_for_order?" do
-    subject { payment_method.available_for_order?(order) }
+  describe "#excluded_product?" do
+    subject { payment_method.excluded_product?(product) }
 
-    let(:preferred_minimum_amount) { nil }
-    let(:preferred_maximum_amount) { nil }
-    let(:preferred_currency) { nil }
+    let(:product) { create(:base_product) }
+    let(:excluded_product_ids) { product.id.to_s }
+    let(:payment_method) { described_class.new(preferred_excluded_products: excluded_product_ids) }
 
-    let(:payment_method) do
-      described_class.new(
-        preferred_minimum_amount: preferred_minimum_amount,
-        preferred_maximum_amount: preferred_maximum_amount,
-        preferred_currency: preferred_currency
-      )
+    context 'when the product is excluded' do
+      it { is_expected.to be_truthy }
     end
 
-    let(:order) { build(:order, currency: order_currency, total: order_total) }
-    let(:order_total) { 5 }
-    let(:order_currency) { 'USD' }
-
-    let(:configuration) do
-      require 'hashie'
+    context 'when the product is not excluded' do
+      let(:excluded_product_ids) { '' }
 
-      Hashie::Mash.new({
-        minimumAmount: { amount: '1', currency: 'USD' },
-        maximumAmount: { amount: '10', currency: 'USD' }
-      })
+      it { is_expected.to be_falsey }
     end
+  end
 
-    before do
-      allow(payment_method.gateway).to receive(:retrieve_configuration).and_return(configuration)
+  describe "#available_for_order?" do
+    subject { payment_method.available_for_order?(order) }
+
+    let(:product) { create(:base_product) }
+    let(:excluded_product_ids) { '' }
+    let(:payment_method) { create(:afterpay_payment_method, preferred_excluded_products: excluded_product_ids) }
+    let(:order) {
+      build(:order_with_line_items, currency: order_currency,
+     line_items_attributes: line_items_attributes)
+    }
+    let(:line_items_attributes) do
+      [{ product: product }]
     end
+    let(:order_currency) { 'USD' }
 
-    context 'when preference settings are nil' do
+    context "with cache" do
       context 'when order total is inside the range' do
+        before do
+          Rails.cache.write("solidus_afterpay_configuration_maximumAmount_currency", "USD")
+          Rails.cache.write("solidus_afterpay_configuration_maximumAmount_amount", 1000.0)
+          Rails.cache.write("solidus_afterpay_configuration_minimumAmount_amount", 1.0)
+        end
+
         it { is_expected.to be(true) }
       end
 
       context 'when order total is outside the range' do
-        let(:order_total) { 11 }
+        before do
+          Rails.cache.write("solidus_afterpay_configuration_maximumAmount_currency", "USD")
+          Rails.cache.write("solidus_afterpay_configuration_maximumAmount_amount", 4.0)
+          Rails.cache.write("solidus_afterpay_configuration_minimumAmount_amount", 1.0)
+        end
 
         it { is_expected.to be(false) }
       end
 
       context 'when order currency is different from afterpay configuration' do
-        let(:order_currency) { 'EUR' }
+        before do
+          Rails.cache.write("solidus_afterpay_configuration_maximumAmount_amount", 1000.0)
+          Rails.cache.write("solidus_afterpay_configuration_minimumAmount_amount", 1.0)
+          Rails.cache.write("solidus_afterpay_configuration_maximumAmount_currency", "EUR")
+        end
 
         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' } })
+      context 'when order currency is the same from afterpay configuration' do
+        before do
+          Rails.cache.write("solidus_afterpay_configuration_maximumAmount_amount", 1000.0)
+          Rails.cache.write("solidus_afterpay_configuration_minimumAmount_amount", 1.0)
+          Rails.cache.write("solidus_afterpay_configuration_maximumAmount_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 there is no cache' do
+      let(:configuration) do
+        require 'hashie'
 
-      context 'when order total is inside the range' do
+        Hashie::Mash.new({
+          minimumAmount: { amount: '1', currency: 'USD' },
+          maximumAmount: { amount: '110', currency: 'USD' }
+        })
+      end
+
+      before do
+        allow(payment_method.gateway).to receive(:retrieve_configuration).and_return(configuration)
+      end
+
+      context 'when order total is inside the range and the currency is the same from afterpay configuration' 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) }
+        it do
+          order.update(total: 111)
+          is_expected.to be(false)
+        end
       end
 
       context 'when order currency is different from afterpay configuration' do
@@ -139,5 +164,44 @@ RSpec.describe SolidusAfterpay::PaymentMethod, type: :model do
         it { is_expected.to be(false) }
       end
     end
+
+    context "when the items are excluded from the payment_method" do
+      let(:excluded_product_ids) { product.id.to_s }
+
+      context "when the id's of all the products are excluded" do
+        it { is_expected.to be_falsey }
+      end
+
+      context "when the id of one of the products is excluded" do
+        let(:second_product) { create(:base_product) }
+        let(:line_items_attributes) do
+          [{ product: product }, { product: second_product }]
+        end
+
+        it { is_expected.to be(false) }
+      end
+    end
+
+    context "when none of the items are excluded from the payment_method" do
+      let(:configuration) do
+        require 'hashie'
+
+        Hashie::Mash.new({
+          minimumAmount: { amount: '1', currency: 'USD' },
+          maximumAmount: { amount: '1000', currency: 'USD' }
+        })
+      end
+
+      let(:excluded_product_ids) { '' }
+
+      before do
+        Rails.cache.clear
+        allow(payment_method.gateway).to receive(:retrieve_configuration).and_return(configuration)
+      end
+
+      it "returns true when none of the products are excluded" do
+        is_expected.to be(true)
+      end
+    end
   end
 end

data/spec/models/solidus_afterpay/payment_source_spec.rb

@@ -14,8 +14,8 @@ RSpec.describe SolidusAfterpay::PaymentSource, type: :model do
   describe '#can_void?' do
     subject { payment_source.can_void?(payment) }
 
-    let(:deferred?) { false }
-    let(:payment_method) { build(:afterpay_payment_method, preferred_deferred: deferred?) }
+    let(:auto_capture) { true }
+    let(:payment_method) { build(:afterpay_payment_method, auto_capture: auto_capture) }
     let(:payment) { build(:afterpay_payment, payment_method: payment_method) }
 
     context 'with the immediate flow' do
@@ -25,7 +25,7 @@ RSpec.describe SolidusAfterpay::PaymentSource, type: :model do
     end
 
     context 'with the deferred flow' do
-      let(:deferred?) { true }
+      let(:auto_capture) { false }
 
       let(:payment_state) { 'AUTH_APPROVED' }
       let(:gateway_response) { { paymentState: payment_state } }

data/spec/presenters/solidus_afterpay/order_presenter_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe SolidusAfterpay::OrderPresenter do
+  describe '#line_items_tax_amount' do
+    subject(:line_items_tax_amount) { described_class.new(order: order).line_items_tax_amount }
+
+    describe '#line_items_tax_amount' do
+      before do
+        country = create(:country)
+        state = create(:state, country: country)
+        zone = create(:zone, country_ids: [country.id], state_ids: [state.id])
+        create(:tax_rate, zone: zone)
+      end
+
+      context 'when the order has line items' do
+        let(:order) { create(:order_with_line_items, line_items_count: 2) }
+
+        it 'returns the line items tax total amout' do
+          expect(line_items_tax_amount).to eq(2.0)
+        end
+      end
+
+      context 'when the order does not have line items' do
+        let(:order) { create(:order) }
+
+        it 'returns 0' do
+          expect(line_items_tax_amount).to eq(0)
+        end
+      end
+    end
+  end
+end

data/spec/presenters/solidus_afterpay/shipping_rate_presenter_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe SolidusAfterpay::ShippingRatePresenter do
+  let(:order) { create(:order_with_line_items ) }
+  let(:shipment) { create(:shipment, order: order) }
+  let(:shipping_rate) { create(:shipping_rate, cost: 5, shipment: shipment) }
+  let(:shipping_rate_tax) { ::Spree::ShippingRateTax.create(amount: 0.75, shipping_rate: shipping_rate) }
+
+  before { shipping_rate.taxes << shipping_rate_tax }
+
+  describe '#order_amount' do
+    subject(:order_amount) { described_class.new(shipping_rate: shipping_rate).order_amount }
+
+    it 'returns the order total including the shipping rate' do
+      expect(order_amount.to_f).to eq(15.75)
+    end
+  end
+
+  describe '#amount_with_taxes' do
+    subject(:amount_with_taxes) { described_class.new(shipping_rate: shipping_rate).amount_with_taxes }
+
+    it 'returns the total amount including taxes' do
+      expect(amount_with_taxes.to_f).to eq(5.75)
+    end
+  end
+end

data/spec/requests/solidus_afterpay/checkouts_controller_spec.rb

@@ -70,7 +70,9 @@ describe SolidusAfterpay::CheckoutsController, type: :request do
               expect(gateway).to have_received(:create_checkout).with(
                 order,
                 redirect_confirm_url: redirect_confirm_url,
-                redirect_cancel_url: redirect_cancel_url
+                redirect_cancel_url: redirect_cancel_url,
+                mode: nil,
+                popup_origin_url: nil
               )
             end
           end
@@ -80,15 +82,49 @@ describe SolidusAfterpay::CheckoutsController, type: :request do
             let(:redirect_cancel_url) { 'http://www.example.com/cancel_url' }
 
             let(:params) do
-              { order_number: order_number, payment_method_id: payment_method_id,
-                redirect_confirm_url: redirect_confirm_url, redirect_cancel_url: redirect_cancel_url }
+              {
+                order_number: order_number,
+                payment_method_id: payment_method_id,
+                redirect_confirm_url: redirect_confirm_url,
+                redirect_cancel_url: redirect_cancel_url
+              }
             end
 
             it 'calls the create_checkout with the correct arguments' do
               expect(gateway).to have_received(:create_checkout).with(
                 order,
                 redirect_confirm_url: redirect_confirm_url,
-                redirect_cancel_url: redirect_cancel_url
+                redirect_cancel_url: redirect_cancel_url,
+                mode: nil,
+                popup_origin_url: nil
+              )
+            end
+          end
+
+          context 'when the mode is passed as params' do
+            let(:params) do
+              {
+                order_number: order_number,
+                payment_method_id: payment_method_id,
+                mode: 'express'
+              }
+            end
+
+            let(:redirect_confirm_url) do
+              "http://www.example.com/solidus_afterpay/callbacks/confirm?order_number=#{order.number}&payment_method_id=#{payment_method.id}"
+            end
+
+            let(:redirect_cancel_url) do
+              "http://www.example.com/solidus_afterpay/callbacks/cancel?order_number=#{order.number}&payment_method_id=#{payment_method.id}"
+            end
+
+            it 'calls the create_checkout with the correct arguments' do
+              expect(gateway).to have_received(:create_checkout).with(
+                order,
+                redirect_confirm_url: redirect_confirm_url,
+                redirect_cancel_url: redirect_cancel_url,
+                popup_origin_url: nil,
+                mode: 'express'
               )
             end
           end
@@ -122,6 +158,38 @@ describe SolidusAfterpay::CheckoutsController, type: :request do
           end
         end
 
+        context 'when the payment_method_id is not passed as param' do
+          let(:redirect_confirm_url) do
+            "http://www.example.com/solidus_afterpay/callbacks/confirm?order_number=#{order.number}&payment_method_id=#{payment_method.id}"
+          end
+
+          let(:redirect_cancel_url) do
+            "http://www.example.com/solidus_afterpay/callbacks/cancel?order_number=#{order.number}&payment_method_id=#{payment_method.id}"
+          end
+
+          let(:params) do
+            {
+              order_number: order_number,
+              mode: 'express'
+            }
+          end
+
+          before do
+            payment_method
+            request
+          end
+
+          it 'uses the first solidus afterpay payment method' do
+            expect(gateway).to have_received(:create_checkout).with(
+              order,
+              redirect_confirm_url: redirect_confirm_url,
+              redirect_cancel_url: redirect_cancel_url,
+              popup_origin_url: nil,
+              mode: 'express'
+            )
+          end
+        end
+
         context 'when the gateway responds with error' do
           let(:gateway_response_success?) { false }
           let(:gateway_response_message) { 'Error message' }