solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/models/spree/refund_spec.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Refund, type: :model do
+  describe 'create' do
+    let(:amount) { 100.0 }
+    let(:amount_in_cents) { amount * 100 }
+
+    let(:authorization) { generate(:refund_transaction_id) }
+
+    let(:payment) { create(:payment, amount: payment_amount, payment_method: payment_method) }
+    let(:payment_amount) { amount * 2 }
+    let(:payment_method) { create(:credit_card_payment_method) }
+
+    let(:refund_reason) { create(:refund_reason) }
+
+    let(:gateway_response) {
+      ActiveMerchant::Billing::Response.new(
+        gateway_response_success,
+        gateway_response_message,
+        gateway_response_params,
+        gateway_response_options
+      )
+    }
+    let(:gateway_response_success) { true }
+    let(:gateway_response_message) { "" }
+    let(:gateway_response_params) { {} }
+    let(:gateway_response_options) { {} }
+
+    subject { create(:refund, payment: payment, amount: amount, reason: refund_reason, transaction_id: nil) }
+
+    before do
+      allow(payment.payment_method)
+        .to receive(:credit)
+        .with(amount_in_cents, payment.source, payment.transaction_id, { originator: an_instance_of(Spree::Refund) })
+        .and_return(gateway_response)
+    end
+
+    context "transaction id exists on creation" do
+      let(:transaction_id) { "12kfjas0" }
+      subject { create(:refund, payment: payment, amount: amount, reason: refund_reason, transaction_id: transaction_id) }
+
+      it "creates a refund record" do
+        expect{ subject }.to change { Spree::Refund.count }.by(1)
+      end
+
+      it "maintains the transaction id" do
+        expect(subject.reload.transaction_id).to eq transaction_id
+      end
+
+      it "saves the amount" do
+        expect(subject.reload.amount).to eq amount
+      end
+
+      it "creates a log entry" do
+        expect(subject.log_entries).to be_present
+      end
+
+      it "does not attempt to process a transaction" do
+        expect(payment.payment_method).not_to receive(:credit)
+        subject
+      end
+    end
+
+    context "processing is successful" do
+      let(:gateway_response_options) { { authorization: authorization } }
+
+      it 'should create a refund' do
+        expect{ subject }.to change{ Spree::Refund.count }.by(1)
+      end
+
+      it 'return the newly created refund' do
+        expect(subject).to be_a(Spree::Refund)
+      end
+
+      it 'should save the returned authorization value' do
+        expect(subject.reload.transaction_id).to eq authorization
+      end
+
+      it 'should save the passed amount as the refund amount' do
+        expect(subject.amount).to eq amount
+      end
+
+      it 'should create a log entry' do
+        expect(subject.log_entries).to be_present
+      end
+
+      it "attempts to process a transaction" do
+        expect(payment.payment_method).to receive(:credit).once
+        subject
+      end
+
+      it 'should update the payment total' do
+        expect(payment.order.updater).to receive(:update)
+        subject
+      end
+    end
+
+    context "processing fails" do
+      let(:gateway_response_success) { false }
+      let(:gateway_response_message) { "failure message" }
+
+      it 'should raise error and not create a refund' do
+        expect do
+          expect { subject }.to raise_error(Spree::Core::GatewayError, gateway_response_message)
+        end.to_not change{ Spree::Refund.count }
+      end
+    end
+
+    context 'without payment profiles supported' do
+      before do
+        allow(payment.payment_method).to receive(:payment_profiles_supported?) { false }
+      end
+
+      it 'should not supply the payment source' do
+        expect(payment.payment_method)
+          .to receive(:credit)
+          .with(amount * 100, payment.transaction_id, { originator: an_instance_of(Spree::Refund) })
+          .and_return(gateway_response)
+
+        subject
+      end
+    end
+
+    context 'with payment profiles supported' do
+      before do
+        allow(payment.payment_method).to receive(:payment_profiles_supported?) { true }
+      end
+
+      it 'should supply the payment source' do
+        expect(payment.payment_method)
+          .to receive(:credit)
+          .with(amount_in_cents, payment.source, payment.transaction_id, { originator: an_instance_of(Spree::Refund) })
+          .and_return(gateway_response)
+
+        subject
+      end
+    end
+
+    context 'with an activemerchant gateway connection error' do
+      before do
+        expect(payment.payment_method)
+          .to receive(:credit)
+          .with(amount_in_cents, payment.source, payment.transaction_id, { originator: an_instance_of(Spree::Refund) })
+          .and_raise(ActiveMerchant::ConnectionError.new("foo", nil))
+      end
+
+      it 'raises Spree::Core::GatewayError' do
+        expect { subject }.to raise_error(Spree::Core::GatewayError, I18n.t('spree.unable_to_connect_to_gateway'))
+      end
+    end
+
+    context 'with amount too large' do
+      let(:payment_amount) { 10 }
+      let(:amount) { payment_amount * 2 }
+
+      it 'is invalid' do
+        expect { subject }.to raise_error { |error|
+          expect(error).to be_a(ActiveRecord::RecordInvalid)
+          expect(error.record.errors.full_messages).to eq ["Amount #{I18n.t('activerecord.errors.models.spree/refund.attributes.amount.greater_than_allowed')}"]
+        }
+      end
+    end
+
+    context 'when payment is not present' do
+      let(:refund) { build(:refund, payment: nil) }
+
+      it 'returns a validation error' do
+        expect { refund.save! }.to raise_error 'Validation failed: Payment can\'t be blank'
+      end
+    end
+  end
+
+  describe 'total_amount_reimbursed_for' do
+    let(:customer_return) { reimbursement.customer_return }
+    let(:reimbursement) { create(:reimbursement) }
+    let!(:default_refund_reason) { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
+
+    subject { Spree::Refund.total_amount_reimbursed_for(reimbursement) }
+
+    context 'with reimbursements performed' do
+      before { reimbursement.perform! }
+
+      it 'returns the total amount' do
+        amount = Spree::Refund.total_amount_reimbursed_for(reimbursement)
+        expect(amount).to be > 0
+        expect(amount).to eq reimbursement.total
+      end
+    end
+
+    context 'without reimbursements performed' do
+      it 'returns zero' do
+        amount = Spree::Refund.total_amount_reimbursed_for(reimbursement)
+        expect(amount).to eq 0
+      end
+    end
+  end
+end

data/spec/models/spree/reimbursement/credit_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  RSpec.describe Reimbursement::Credit, type: :model do
+    context 'class methods' do
+      describe '.total_amount_reimbursed_for' do
+        subject { Spree::Reimbursement::Credit.total_amount_reimbursed_for(reimbursement) }
+
+        let(:reimbursement) { create(:reimbursement) }
+        let(:credit_double) { double(amount: 99.99) }
+
+        before { allow(reimbursement).to receive(:credits).and_return([credit_double, credit_double]) }
+
+        it 'should sum the amounts of all of the reimbursements credits' do
+          expect(subject).to eq BigDecimal('199.98')
+        end
+      end
+    end
+
+    describe '#description' do
+      let(:credit) { Spree::Reimbursement::Credit.new(amount: 100, creditable: mock_model(Spree::PaymentMethod::Check)) }
+
+      it "should be the creditable's class name" do
+        expect(credit.description).to eq 'Check'
+      end
+    end
+
+    describe '#display_amount' do
+      let(:credit) { Spree::Reimbursement::Credit.new(amount: 100) }
+
+      it 'should be a money object' do
+        expect(credit.display_amount).to eq Spree::Money.new(100, currency: "USD")
+      end
+    end
+  end
+end

data/spec/models/spree/reimbursement/reimbursement_type_engine_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  RSpec.describe Reimbursement::ReimbursementTypeEngine, type: :model do
+    describe '#calculate_reimbursement_types' do
+      let(:return_item)   { create(:return_item) }
+      let(:return_items)  { [return_item] }
+      let(:reimbursement_type_engine) { Spree::Reimbursement::ReimbursementTypeEngine.new(return_items) }
+      let(:expired_reimbursement_type) { Spree::ReimbursementType::OriginalPayment }
+      let(:override_reimbursement_type) { Spree::ReimbursementType::OriginalPayment.new }
+      let(:preferred_reimbursement_type) { Spree::ReimbursementType::OriginalPayment.new }
+      let(:calculated_reimbursement_types) { subject }
+      let(:all_reimbursement_types) {
+        [
+                                        reimbursement_type_engine.default_reimbursement_type,
+                                        reimbursement_type_engine.exchange_reimbursement_type,
+                                        expired_reimbursement_type,
+                                        override_reimbursement_type,
+                                        preferred_reimbursement_type
+                                    ]
+      }
+
+      subject { reimbursement_type_engine.calculate_reimbursement_types }
+
+      shared_examples_for "reimbursement type hash" do
+        it "contain all keys that respond to reimburse" do
+          calculated_reimbursement_types.keys.each do |r_type|
+            expect(r_type).to respond_to :reimburse
+          end
+        end
+      end
+
+      before do
+        reimbursement_type_engine.expired_reimbursement_type = expired_reimbursement_type
+        allow(return_item.inventory_unit.shipment).to receive(:shipped_at).and_return(Date.yesterday)
+        allow(return_item).to receive(:exchange_required?).and_return(false)
+      end
+
+      context 'the return item requires exchange' do
+        before { allow(return_item).to receive(:exchange_required?).and_return(true) }
+
+        it 'returns a hash with the exchange reimbursement type associated to the return items' do
+          expect(calculated_reimbursement_types[reimbursement_type_engine.exchange_reimbursement_type]).to eq(return_items)
+        end
+
+        it 'the return items are not included in any of the other reimbursement types' do
+          (all_reimbursement_types - [reimbursement_type_engine.exchange_reimbursement_type]).each do |r_type|
+            expect(calculated_reimbursement_types[r_type]).to eq([])
+          end
+        end
+
+        it_should_behave_like 'reimbursement type hash'
+      end
+
+      context 'the return item does not require exchange' do
+        context 'the return item has an override reimbursement type' do
+          before { allow(return_item).to receive(:override_reimbursement_type).and_return(override_reimbursement_type) }
+
+          it 'returns a hash with the override reimbursement type associated to the return items' do
+            expect(calculated_reimbursement_types[override_reimbursement_type.class]).to eq(return_items)
+          end
+
+          it 'the return items are not included in any of the other reimbursement types' do
+            (all_reimbursement_types - [override_reimbursement_type.class]).each do |r_type|
+              expect(calculated_reimbursement_types[r_type]).to eq([])
+            end
+          end
+
+          it_should_behave_like 'reimbursement type hash'
+        end
+
+        context 'the return item does not have an override reimbursement type' do
+          context 'the return item has a preferred reimbursement type' do
+            before { allow(return_item).to receive(:preferred_reimbursement_type).and_return(preferred_reimbursement_type) }
+
+            context 'the reimbursement type is not valid for the return item' do
+              before { expect(reimbursement_type_engine).to receive(:valid_preferred_reimbursement_type?).and_return(false) }
+
+              it 'returns a hash with no return items associated to the preferred reimbursement type' do
+                expect(calculated_reimbursement_types[preferred_reimbursement_type]).to eq([])
+              end
+
+              it 'the return items are not included in any of the other reimbursement types' do
+                (all_reimbursement_types - [preferred_reimbursement_type]).each do |r_type|
+                  expect(calculated_reimbursement_types[r_type]).to eq([])
+                end
+              end
+
+              it_should_behave_like 'reimbursement type hash'
+            end
+
+            context 'the reimbursement type is valid for the return item' do
+              it 'returns a hash with the expired reimbursement type associated to the return items' do
+                expect(calculated_reimbursement_types[preferred_reimbursement_type.class]).to eq(return_items)
+              end
+
+              it 'the return items are not included in any of the other reimbursement types' do
+                (all_reimbursement_types - [preferred_reimbursement_type.class]).each do |r_type|
+                  expect(calculated_reimbursement_types[r_type]).to eq([])
+                end
+              end
+
+              it_should_behave_like 'reimbursement type hash'
+            end
+          end
+
+          context 'the return item does not have a preferred reimbursement type' do
+            context 'the return item is past the time constraint' do
+              before { allow(reimbursement_type_engine).to receive(:past_reimbursable_time_period?).and_return(true) }
+
+              it 'returns a hash with the expired reimbursement type associated to the return items' do
+                expect(calculated_reimbursement_types[expired_reimbursement_type]).to eq(return_items)
+              end
+
+              it 'the return items are not included in any of the other reimbursement types' do
+                (all_reimbursement_types - [expired_reimbursement_type]).each do |r_type|
+                  expect(calculated_reimbursement_types[r_type]).to eq([])
+                end
+              end
+
+              it_should_behave_like 'reimbursement type hash'
+            end
+
+            context 'the return item is within the time constraint' do
+              it 'returns a hash with the default reimbursement type associated to the return items' do
+                expect(calculated_reimbursement_types[reimbursement_type_engine.default_reimbursement_type]).to eq(return_items)
+              end
+
+              it 'the return items are not included in any of the other reimbursement types' do
+                (all_reimbursement_types - [reimbursement_type_engine.default_reimbursement_type]).each do |r_type|
+                  expect(calculated_reimbursement_types[r_type]).to eq([])
+                end
+              end
+
+              it_should_behave_like 'reimbursement type hash'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/reimbursement/reimbursement_type_validator_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  RSpec.describe Reimbursement::ReimbursementTypeValidator, type: :model do
+    class DummyClass
+      include Spree::Reimbursement::ReimbursementTypeValidator
+
+      class_attribute :expired_reimbursement_type
+      self.expired_reimbursement_type = Spree::ReimbursementType::Credit
+
+      class_attribute :refund_time_constraint
+      self.refund_time_constraint = 90.days
+    end
+
+    let(:return_item) do
+      create(
+        :return_item,
+        preferred_reimbursement_type: preferred_reimbursement_type
+      )
+    end
+    let(:dummy) { DummyClass.new }
+    let(:preferred_reimbursement_type) { Spree::ReimbursementType::Credit.new }
+
+    describe '#valid_preferred_reimbursement_type?' do
+      before do
+        allow(dummy).to receive(:past_reimbursable_time_period?).and_return(true)
+      end
+
+      subject { dummy.valid_preferred_reimbursement_type?(return_item) }
+
+      context 'is valid' do
+        it 'if it is not past the reimbursable time period' do
+          allow(dummy).to receive(:past_reimbursable_time_period?).and_return(false)
+          expect(subject).to be true
+        end
+
+        it 'if the return items preferred method of reimbursement is the expired method of reimbursement' do
+          expect(subject).to be true
+        end
+      end
+
+      context 'is invalid' do
+        it 'if the return item is past the eligible time period and the preferred method of reimbursement is not the expired method of reimbursement' do
+          return_item.preferred_reimbursement_type =
+            Spree::ReimbursementType::OriginalPayment.new
+          expect(subject).to be false
+        end
+      end
+    end
+
+    describe '#past_reimbursable_time_period?' do
+      subject { dummy.past_reimbursable_time_period?(return_item) }
+
+      before do
+        allow(return_item).to receive_message_chain(:inventory_unit, :shipment, :shipped_at).and_return(shipped_at)
+      end
+
+      context 'it has not shipped' do
+        let(:shipped_at) { nil }
+
+        it 'is not past the reimbursable time period' do
+          expect(subject).to be_falsey
+        end
+      end
+
+      context 'it has shipped and it is more recent than the time constraint' do
+        let(:shipped_at) { (dummy.refund_time_constraint - 1.day).ago }
+
+        it 'is not past the reimbursable time period' do
+          expect(subject).to be false
+        end
+      end
+
+      context 'it has shipped and it is further in the past than the time constraint' do
+        let(:shipped_at) { (dummy.refund_time_constraint + 1.day).ago }
+
+        it 'is past the reimbursable time period' do
+          expect(subject).to be true
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/reimbursement_performer_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::ReimbursementPerformer, type: :model do
+  let(:reimbursement)           { create(:reimbursement, return_items_count: 1) }
+  let(:return_item)             { reimbursement.return_items.first }
+  let(:reimbursement_type)      { double("ReimbursementType") }
+  let(:reimbursement_type_hash) { { reimbursement_type => [return_item] } }
+
+  before do
+    expect(Spree::ReimbursementPerformer).to receive(:calculate_reimbursement_types).and_return(reimbursement_type_hash)
+  end
+
+  describe ".simulate" do
+    subject { Spree::ReimbursementPerformer.simulate(reimbursement) }
+
+    it "reimburses each calculated reimbursement types with the correct return items as a simulation" do
+      expect(reimbursement_type).to receive(:reimburse).with(reimbursement, [return_item], true)
+      subject
+    end
+  end
+
+  describe '.perform' do
+    subject { Spree::ReimbursementPerformer.perform(reimbursement) }
+
+    it "reimburses each calculated reimbursement types with the correct return items as a simulation" do
+      expect(reimbursement_type).to receive(:reimburse).with(reimbursement, [return_item], false)
+      subject
+    end
+  end
+end