solidus_afterpay 0.2.0 → 0.3.0

data/spec/models/solidus_afterpay/payment_method_spec.rb

@@ -1,207 +0,0 @@
-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 "#excluded_product?" do
-    subject { payment_method.excluded_product?(product) }
-
-    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) }
-
-    context 'when the product is excluded' do
-      it { is_expected.to be_truthy }
-    end
-
-    context 'when the product is not excluded' do
-      let(:excluded_product_ids) { '' }
-
-      it { is_expected.to be_falsey }
-    end
-  end
-
-  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 "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
-        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
-        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 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 there is no cache' do
-      let(:configuration) do
-        require 'hashie'
-
-        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
-        it do
-          order.update(total: 111)
-          is_expected.to be(false)
-        end
-      end
-
-      context 'when order currency is different from afterpay configuration' do
-        let(:order_currency) { 'EUR' }
-
-        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

@@ -1,61 +0,0 @@
-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(: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
-      it 'is always false' do
-        is_expected.to be(false)
-      end
-    end
-
-    context 'with the deferred flow' do
-      let(:auto_capture) { false }
-
-      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

@@ -1,22 +0,0 @@
-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

@@ -1,158 +0,0 @@
-# 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

data/spec/presenters/solidus_afterpay/order_presenter_spec.rb

@@ -1,34 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-# 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/callbacks_controller_spec.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe SolidusAfterpay::CallbacksController, type: :request do
-  describe 'GET cancel' do
-    subject(:request) { get '/solidus_afterpay/callbacks/cancel', params: params }
-
-    let(:order) { create(:order_with_totals, state: 'payment') }
-
-    let(:params) { { order_number: order.number } }
-
-    it 'redirects to the order current checkout state page' do
-      request
-      expect(response).to redirect_to('/checkout/payment')
-    end
-  end
-
-  describe 'GET confirm' do
-    subject(:request) { get '/solidus_afterpay/callbacks/confirm', params: params }
-
-    let(:order) { create(:order_with_totals, state: 'payment', user: user) }
-    let(:payment_method) { create(:afterpay_payment_method) }
-    let(:user) { create(:user) }
-
-    let(:order_token) { 'ORDER_TOKEN' }
-    let(:order_number) { order.number }
-    let(:payment_method_id) { payment_method.id }
-
-    let(:params) { { orderToken: order_token, order_number: order_number, payment_method_id: payment_method_id } }
-
-    context 'when the user is logged in', with_signed_in_user: true do
-      context 'with valid data' do
-        it 'redirects to the order next checkout state page' do
-          request
-          expect(response).to redirect_to('/checkout/confirm')
-        end
-
-        it 'moves the order to its next state' do
-          expect { request }.to change { order.reload.state }.from('payment').to('confirm')
-        end
-
-        it 'creates a payment' do
-          expect { request }.to change { order.payments.count }.from(0).to(1)
-        end
-
-        it 'sets the payment total equal to the order total' do
-          request
-          expect(order.payments.last.amount).to eq(order.total)
-        end
-
-        it 'creates a payment source and assigns the order token to it' do
-          request
-          expect(order.payments.last.payment_source.token).to eq(order_token)
-        end
-      end
-
-      context 'when the order_token is missing' do
-        let(:order_token) { nil }
-
-        it 'redirects to the order current checkout state page' do
-          request
-          expect(response).to redirect_to('/checkout/payment')
-        end
-      end
-
-      context 'when the order_number is invalid' do
-        let(:order_number) { 'INVALID_ORDER_NUMBER' }
-
-        it 'redirects to the cart page' do
-          request
-          expect(response).to redirect_to('/cart')
-        end
-
-        it 'sets a resource not found flash message' do
-          request
-          expect(flash[:notice]).to eq('The resource you were looking for could not be found.')
-        end
-      end
-
-      context 'when the payment_method_id is invalid' do
-        let(:payment_method_id) { 0 }
-
-        it 'redirects to the cart page' do
-          request
-          expect(response).to redirect_to('/cart')
-        end
-
-        it 'sets a resource not found flash message' do
-          request
-          expect(flash[:notice]).to eq('The resource you were looking for could not be found.')
-        end
-      end
-
-      context 'when the order is already in confirm state' do
-        let(:order) { create(:order_with_totals, state: 'confirm') }
-
-        it "doesn't move the order to its next state" do
-          expect { request }.not_to(change { order.reload.state })
-        end
-      end
-
-      context 'when the order is already completed' do
-        let(:order) { create(:completed_order_with_totals) }
-
-        it 'redirects to the order detail page' do
-          request
-          expect(response).to redirect_to("/orders/#{order.number}")
-        end
-      end
-    end
-
-    context 'when the user is a guest user', with_guest_session: true do
-      it 'redirects to the order next checkout state page' do
-        request
-        expect(response).to redirect_to('/checkout/confirm')
-      end
-    end
-
-    context 'when the user is not logged in' do
-      it 'redirects the user to vallalah' do
-        request
-        expect(response).to redirect_to('/cart')
-      end
-    end
-  end
-end