spree_core 3.2.9 → 3.3.0.rc1

data/spec/models/spree/reimbursement_performer_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+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

data/spec/models/spree/reimbursement_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe Spree::Reimbursement, type: :model do
+
+  describe "#display_total" do
+    let(:total)         { 100.50 }
+    let(:currency)      { "USD" }
+    let(:order)         { Spree::Order.new(currency: currency) }
+    let(:reimbursement) { Spree::Reimbursement.new(total: total, order: order) }
+
+    subject { reimbursement.display_total }
+
+    it "returns the value as a Spree::Money instance" do
+      expect(subject).to eq Spree::Money.new(total)
+    end
+
+    it "uses the order's currency" do
+      expect(subject.money.currency.to_s).to eq currency
+    end
+  end
+
+  describe "#perform!" do
+    let!(:adjustments)            { [] } # placeholder to ensure it gets run prior the "before" at this level
+
+    let!(:tax_rate)               { nil }
+    let!(:tax_zone) { create(:zone_with_country, default_tax: true) }
+
+    let(:order)                   { create(:order_with_line_items, state: 'payment', line_items_count: 1, line_items_price: line_items_price, shipment_cost: 0) }
+    let(:line_items_price)        { BigDecimal.new(10) }
+    let(:line_item)               { order.line_items.first }
+    let(:inventory_unit)          { line_item.inventory_units.first }
+    let(:payment)                 { build(:payment, amount: payment_amount, order: order, state: 'completed') }
+    let(:payment_amount)          { order.total }
+    let(:customer_return)         { build(:customer_return, return_items: [return_item]) }
+    let(:return_item)             { build(:return_item, inventory_unit: inventory_unit) }
+
+    let!(:default_refund_reason) { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
+
+    let(:reimbursement) { create(:reimbursement, customer_return: customer_return, order: order, return_items: [return_item]) }
+
+    subject { reimbursement.perform! }
+
+    before do
+      order.shipments.each do |shipment|
+        shipment.inventory_units.update_all state: 'shipped'
+        shipment.update_column('state', 'shipped')
+      end
+      order.reload
+      order.update_with_updater!
+      if payment
+        payment.save!
+        order.next! # confirm
+      end
+      order.next! # completed
+      customer_return.save!
+      return_item.accept!
+    end
+
+    it "refunds the total amount" do
+      subject
+      expect(reimbursement.unpaid_amount).to eq 0
+    end
+
+    it "creates a refund" do
+      expect {
+        subject
+      }.to change{ Spree::Refund.count }.by(1)
+      expect(Spree::Refund.last.amount).to eq order.total
+    end
+
+    context 'with additional tax' do
+      let!(:tax_rate) { create(:tax_rate, name: "Sales Tax", amount: 0.10, included_in_price: false, zone: tax_zone) }
+
+      it 'saves the additional tax and refunds the total' do
+        expect {
+          subject
+        }.to change { Spree::Refund.count }.by(1)
+        return_item.reload
+        expect(return_item.additional_tax_total).to be > 0
+        expect(return_item.additional_tax_total).to eq line_item.additional_tax_total
+        expect(reimbursement.total).to eq line_item.pre_tax_amount + line_item.additional_tax_total
+        expect(Spree::Refund.last.amount).to eq line_item.pre_tax_amount + line_item.additional_tax_total
+      end
+    end
+
+    context 'with included tax' do
+      let!(:tax_rate) { create(:tax_rate, name: "VAT Tax", amount: 0.1, included_in_price: true, zone: tax_zone) }
+
+      it 'saves the included tax and refunds the total' do
+        expect {
+          subject
+        }.to change { Spree::Refund.count }.by(1)
+        return_item.reload
+        expect(return_item.included_tax_total).to be > 0
+        expect(return_item.included_tax_total).to eq line_item.included_tax_total
+        expect(reimbursement.total).to eq (line_item.pre_tax_amount + line_item.included_tax_total).round(2)
+        expect(Spree::Refund.last.amount).to eq (line_item.pre_tax_amount + line_item.included_tax_total).round(2)
+      end
+    end
+
+    context 'when reimbursement cannot be fully performed' do
+      let!(:non_return_refund) { create(:refund, amount: 1, payment: payment) }
+
+      it 'raises IncompleteReimbursement error' do
+        expect { subject }.to raise_error(Spree::Reimbursement::IncompleteReimbursementError)
+      end
+    end
+
+    context "when exchange is required" do
+      let(:exchange_variant) { build(:variant) }
+      before { return_item.exchange_variant = exchange_variant }
+      it "generates an exchange shipment for the order for the exchange items" do
+        expect { subject }.to change { order.reload.shipments.count }.by 1
+        expect(order.shipments.last.inventory_units.first.variant).to eq exchange_variant
+      end
+    end
+
+    it "triggers the reimbursement mailer to be sent" do
+      expect(Spree::ReimbursementMailer).to receive(:reimbursement_email).with(reimbursement.id) { double(deliver_later: true) }
+      subject
+    end
+  end
+
+  describe "#return_items_requiring_exchange" do
+    it "returns only the return items that require an exchange" do
+      return_items = [double(exchange_required?: true), double(exchange_required?: true),double(exchange_required?: false)]
+      allow(subject).to receive(:return_items) { return_items }
+      expect(subject.return_items_requiring_exchange).to eq return_items.take(2)
+    end
+  end
+
+  describe "#calculated_total" do
+    context 'with return item amounts that would round up if added' do
+      let(:reimbursement) { Spree::Reimbursement.new }
+
+      subject { reimbursement.calculated_total }
+
+      before do
+        reimbursement.return_items << Spree::ReturnItem.new(pre_tax_amount: 10.003)
+        reimbursement.return_items << Spree::ReturnItem.new(pre_tax_amount: 10.003)
+      end
+
+      it 'rounds down' do
+        expect(subject).to eq 20
+      end
+    end
+
+    context 'with a return item amount that should round up' do
+      let(:reimbursement) { Spree::Reimbursement.new }
+
+      subject { reimbursement.calculated_total }
+
+      before do
+        reimbursement.return_items << Spree::ReturnItem.new(pre_tax_amount: 19.998)
+      end
+
+      it 'rounds up' do
+        expect(subject).to eq 20
+      end
+    end
+  end
+
+  describe '.build_from_customer_return' do
+    let(:customer_return) { create(:customer_return, line_items_count: 5) }
+
+    let!(:pending_return_item) { customer_return.return_items.first.tap { |ri| ri.update!(acceptance_status: 'pending') } }
+    let!(:accepted_return_item) { customer_return.return_items.second.tap(&:accept!) }
+    let!(:rejected_return_item) { customer_return.return_items.third.tap(&:reject!) }
+    let!(:manual_intervention_return_item) { customer_return.return_items.fourth.tap(&:require_manual_intervention!) }
+    let!(:already_reimbursed_return_item) { customer_return.return_items.fifth }
+
+    let!(:previous_reimbursement) { create(:reimbursement, order: customer_return.order, return_items: [already_reimbursed_return_item]) }
+
+    subject { Spree::Reimbursement.build_from_customer_return(customer_return) }
+
+    it 'connects to the accepted return items' do
+      expect(subject.return_items.to_a).to eq [accepted_return_item]
+    end
+
+    it 'connects to the order' do
+      expect(subject.order).to eq customer_return.order
+    end
+
+    it 'connects to the customer_return' do
+      expect(subject.customer_return).to eq customer_return
+    end
+  end
+end

data/spec/models/spree/reimbursement_tax_calculator_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Spree::ReimbursementTaxCalculator, type: :model do
+
+  let!(:tax_rate) { nil }
+
+  let(:reimbursement) { create(:reimbursement, return_items_count: 1) }
+  let(:return_item) { reimbursement.return_items.first }
+  let(:line_item) { return_item.inventory_unit.line_item }
+
+  subject do
+    Spree::ReimbursementTaxCalculator.call(reimbursement)
+  end
+
+  context 'without taxes' do
+    let!(:tax_rate) { nil }
+
+    it 'leaves the return items additional_tax_total and included_tax_total at zero' do
+      subject
+
+      expect(return_item.additional_tax_total).to eq 0
+      expect(return_item.included_tax_total).to eq 0
+    end
+  end
+
+  context 'with additional tax' do
+    let!(:tax_rate) do
+      create :tax_rate,
+             name: "Sales Tax",
+             amount: 0.10,
+             included_in_price: false,
+             tax_category: create(:tax_category),
+             zone: create(:zone_with_country, default_tax: true)
+    end
+
+    it 'sets additional_tax_total on the return items' do
+      subject
+      return_item.reload
+
+      expect(return_item.additional_tax_total).to be > 0
+      expect(return_item.additional_tax_total).to eq line_item.additional_tax_total
+    end
+  end
+
+  context 'with included tax' do
+    let!(:tax_rate) do
+      create :tax_rate,
+             name: "VAT Tax",
+             amount: 0.10,
+             included_in_price: true,
+             tax_category: create(:tax_category),
+             zone: create(:zone_with_country, default_tax: true)
+    end
+
+    it 'sets included_tax_total on the return items' do
+      subject
+      return_item.reload
+
+      expect(return_item.included_tax_total).to be > 0
+      expect(return_item.included_tax_total).to eq line_item.included_tax_total
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+module Spree
+  describe ReimbursementType::Credit, type: :model do
+    let(:reimbursement)           { create(:reimbursement, return_items_count: 1) }
+    let(:return_item)             { reimbursement.return_items.first }
+    let(:payment)                 { reimbursement.order.payments.first }
+    let(:simulate)                { false }
+    let!(:default_refund_reason)  { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
+    let(:creditable)              { DummyCreditable.new(amount: 99.99) }
+
+    class DummyCreditable < Spree::Base
+      attr_accessor :amount
+      self.table_name = 'spree_payments' # Your creditable class should not use this table
+    end
+
+    subject { Spree::ReimbursementType::Credit.reimburse(reimbursement, [return_item], simulate)}
+
+    before do
+      reimbursement.update!(total: reimbursement.calculated_total)
+      allow(Spree::ReimbursementType::Credit).to receive(:create_creditable).and_return(creditable)
+    end
+
+    describe '.reimburse' do
+      context 'simulate is true' do
+        let(:simulate) { true }
+
+        it 'creates one readonly lump credit for all outstanding balance payable to the customer' do
+          expect(subject.map(&:class)).to eq [Spree::Reimbursement::Credit]
+          expect(subject.map(&:readonly?)).to eq [true]
+          expect(subject.sum(&:amount)).to eq reimbursement.return_items.to_a.sum(&:total)
+        end
+
+        it 'does not save to the database' do
+          expect { subject }.to_not change { Spree::Reimbursement::Credit.count }
+        end
+      end
+
+      context 'simulate is false' do
+        let(:simulate) { false }
+
+        before do
+          expect(creditable).to receive(:save).and_return(true)
+        end
+
+        it 'creates one lump credit for all outstanding balance payable to the customer' do
+          expect { subject }.to change { Spree::Reimbursement::Credit.count }.by(1)
+          expect(subject.sum(&:amount)).to eq reimbursement.return_items.to_a.sum(&:total)
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/reimbursement_type/exchange_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+module Spree
+  describe ReimbursementType::Exchange, type: :model do
+    describe '.reimburse' do
+      let(:reimbursement) { create(:reimbursement, return_items_count: 1) }
+      let(:return_items)  { reimbursement.return_items }
+      let(:new_exchange)  { double("Exchange") }
+      let(:simulate)      { true }
+
+      subject { Spree::ReimbursementType::Exchange.reimburse(reimbursement, return_items, simulate)}
+
+      context 'return items are supplied' do
+        before do
+          expect(Spree::Exchange).to receive(:new).with(reimbursement.order, return_items).and_return(new_exchange)
+        end
+
+        context "simulate is true" do
+
+          it 'does not perform an exchange and returns the exchange object' do
+            expect(new_exchange).not_to receive(:perform!)
+            expect(subject).to eq [new_exchange]
+          end
+        end
+
+        context "simulate is false" do
+          let(:simulate) { false }
+
+          it 'performs an exchange and returns the exchange object' do
+            expect(new_exchange).to receive(:perform!)
+            expect(subject).to eq [new_exchange]
+          end
+        end
+      end
+
+      context "no return items are supplied" do
+        let(:return_items) { [] }
+
+        it 'does not perform an exchange and returns an empty array' do
+          expect(new_exchange).not_to receive(:perform!)
+          expect(subject).to eq []
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/reimbursement_type/original_payment_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module Spree
+  describe ReimbursementType::OriginalPayment, type: :model do
+    let(:reimbursement)           { create(:reimbursement, return_items_count: 1) }
+    let(:return_item)             { reimbursement.return_items.first }
+    let(:payment)                 { reimbursement.order.payments.first }
+    let(:simulate)                { false }
+    let!(:default_refund_reason)  { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
+
+    subject { Spree::ReimbursementType::OriginalPayment.reimburse(reimbursement, [return_item], simulate)}
+
+    before { reimbursement.update!(total: reimbursement.calculated_total) }
+
+    describe ".reimburse" do
+      context "simulate is true" do
+        let(:simulate) { true }
+
+        it "returns an array of readonly refunds" do
+          expect(subject.map(&:class)).to eq [Spree::Refund]
+          expect(subject.map(&:readonly?)).to eq [true]
+        end
+      end
+
+      context "simulate is false" do
+        it 'performs the refund' do
+          expect {
+            subject
+          }.to change { payment.refunds.count }.by(1)
+          expect(payment.refunds.sum(:amount)).to eq reimbursement.return_items.to_a.sum(&:total)
+        end
+      end
+
+      context 'when no credit is allowed on the payment' do
+        before do
+          expect_any_instance_of(Spree::Payment).to receive(:credit_allowed).and_return 0
+        end
+
+        it 'returns an empty array' do
+          expect(subject).to eq []
+        end
+      end
+
+      context 'when a payment is negative' do
+        before do
+          expect_any_instance_of(Spree::Payment).to receive(:amount).and_return -100
+        end
+
+        it 'returns an empty array' do
+          expect(subject).to eq []
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/reimbursement_type/store_credit_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+module Spree
+  describe ReimbursementType::StoreCredit do
+    let(:reimbursement) { create(:reimbursement, return_items_count: 2) }
+    let(:return_item) { reimbursement.return_items.first }
+    let(:return_item2) { reimbursement.return_items.last }
+    let(:payment) { reimbursement.order.payments.first }
+    let(:simulate) { false }
+    let!(:default_refund_reason) do
+      Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON,
+                                             mutable: false)
+    end
+
+    let!(:primary_credit_type) { create(:primary_credit_type) }
+    let!(:created_by_user) { create(:user, email: Spree::StoreCredit::DEFAULT_CREATED_BY_EMAIL) }
+    let!(:default_reimbursement_category) { create(:store_credit_category) }
+
+    subject do
+      Spree::ReimbursementType::StoreCredit.reimburse(reimbursement, [return_item, return_item2],
+                                                      simulate)
+    end
+
+    before { reimbursement.update!(total: reimbursement.calculated_total) }
+
+    describe '.reimburse' do
+      context 'simulate is true' do
+        let(:simulate) { true }
+
+        context 'for store credits that the customer used' do
+          before do
+            allow(Spree::ReimbursementType::StoreCredit).to receive(:store_credit_payments).and_return([payment])
+          end
+
+          it 'creates readonly refunds for all store credit payments' do
+            expect(subject.map(&:class)).to eq [Spree::Refund]
+            expect(subject.map(&:readonly?)).to eq [true]
+          end
+
+          it 'does not save to the database' do
+            expect { subject }.to_not change { payment.refunds.count }
+          end
+        end
+
+        context 'for return items that were not paid for with store credit' do
+          before do
+            allow(Spree::ReimbursementType::StoreCredit).to receive(:store_credit_payments).and_return([])
+          end
+
+          context 'creates one readonly lump credit for all outstanding balance payable to the customer' do
+            it 'creates a credit that is read only' do
+              expect(subject.map(&:class)).to eq [Spree::Reimbursement::Credit]
+              expect(subject.map(&:readonly?)).to eq [true]
+            end
+
+            it 'creates a credit which amounts to the sum of the return items rounded down' do
+              allow(return_item).to receive(:total).and_return(10.0076)
+              allow(return_item2).to receive(:total).and_return(10.0023)
+              expect(subject.sum(&:amount)).to eq 20.0
+            end
+          end
+
+          it 'does not save to the database' do
+            expect { subject }.to_not change { Spree::Reimbursement::Credit.count }
+          end
+        end
+      end
+
+      context 'simulate is false' do
+        let(:simulate) { false }
+
+        context 'for store credits that the customer used' do
+          before do
+            allow(Spree::ReimbursementType::StoreCredit).to receive(:store_credit_payments).and_return([payment])
+          end
+
+          it 'performs refunds for all store credit payments' do
+            expect { subject }.to change { payment.refunds.count }.by(1)
+            expect(payment.refunds.sum(:amount)).to eq reimbursement.return_items.to_a.sum(&:total)
+          end
+        end
+
+        context 'for return items that were not paid for with store credit' do
+          before do
+            allow(Spree::ReimbursementType::StoreCredit).to receive(:store_credit_payments).and_return([])
+          end
+
+          it 'creates one lump credit for all outstanding balance payable to the customer' do
+            expect { subject }.to change { Spree::Reimbursement::Credit.count }.by(1)
+            expect(subject.sum(&:amount)).to eq reimbursement.return_items.to_a.sum(&:total)
+          end
+
+          it "creates a store credit with the same currency as the reimbursement's order" do
+            expect { subject }.to change { Spree::StoreCredit.count }.by(1)
+            expect(Spree::StoreCredit.last.currency).to eq reimbursement.order.currency
+          end
+        end
+      end
+    end
+  end
+end