solidus_core 1.0.2 → 1.0.3

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

@@ -0,0 +1,97 @@
+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)  { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
+
+    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 { Spree::ReimbursementType::StoreCredit.reimburse(reimbursement, [return_item, return_item2], simulate)}
+
+    before do
+      reimbursement.update!(total: reimbursement.calculated_total)
+    end
+
+    describe '.reimburse' do
+      context 'simulate is true' do
+        let(:simulate) { true }
+
+        context 'for store credits that the customer used' do
+          before do
+            expect(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
+            expect(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
+              expect(return_item).to receive(:total).and_return(10.0076)
+              expect(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
+            expect(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
+            expect(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

data/spec/models/spree/return_authorization_spec.rb

@@ -0,0 +1,290 @@
+require 'spec_helper'
+
+describe Spree::ReturnAuthorization, :type => :model do
+  let(:order) { create(:shipped_order) }
+  let(:stock_location) { create(:stock_location) }
+  let(:rma_reason) { create(:return_reason) }
+  let(:inventory_unit_1) { order.inventory_units.first }
+
+  let(:variant) { order.variants.first }
+  let(:return_authorization) do
+    Spree::ReturnAuthorization.new(order: order,
+      stock_location_id: stock_location.id,
+      return_reason_id: rma_reason.id)
+  end
+
+  context "save" do
+    let(:order) { Spree::Order.create }
+
+    it "should be invalid when order has no inventory units" do
+      order.inventory_units.each(&:delete)
+      return_authorization.save
+      expect(return_authorization.errors[:order]).to eq(["has no shipped units"])
+    end
+
+    context "an inventory unit is already being exchanged" do
+      let(:order)                           { create(:shipped_order, line_items_count: 2) }
+      let!(:previous_exchange_return_item)  { create(:exchange_return_item, inventory_unit: order.inventory_units.last) }
+      let(:return_item)                     { create(:return_item, inventory_unit: order.inventory_units.last) }
+      let(:return_authorization)            { build(:return_authorization, order: order, return_items: [return_item]) }
+
+      it "should be invalid" do
+        return_authorization.save
+        expect(return_authorization.errors['base']).to include('Return items cannot be created for inventory units that are already awaiting exchange.')
+      end
+    end
+
+    context "an inventory unit is not being exchanged" do
+      let(:order)                           { create(:shipped_order, line_items_count: 2) }
+      let(:return_item)                     { create(:return_item, inventory_unit: order.inventory_units.last) }
+      let(:return_authorization)            { build(:return_authorization, order: order, return_items: [return_item]) }
+
+      it "is valid" do
+        return_authorization.save
+        expect(return_authorization.errors['base'].size).to eq 0
+      end
+    end
+
+    context "expedited exchanges are configured" do
+      let(:order)                { create(:shipped_order, line_items_count: 2) }
+      let(:exchange_return_item) { build(:exchange_return_item, inventory_unit: order.inventory_units.first) }
+      let(:return_item)          { build(:return_item, inventory_unit: order.inventory_units.last) }
+      subject                    { create(:return_authorization, order: order, return_items: [exchange_return_item, return_item]) }
+
+      before do
+        @expediteted_exchanges_config = Spree::Config[:expedited_exchanges]
+        Spree::Config[:expedited_exchanges] = true
+        @pre_exchange_hooks = subject.class.pre_expedited_exchange_hooks
+      end
+
+      after do
+        Spree::Config[:expedited_exchanges] = @expediteted_exchanges_config
+        subject.class.pre_expedited_exchange_hooks = @pre_exchange_hooks
+      end
+
+      context "no items to exchange" do
+        subject { create(:return_authorization, order: order) }
+
+        it "does not create a reimbursement" do
+          expect{subject.save}.to_not change { Spree::Reimbursement.count }
+        end
+      end
+
+      context "items to exchange" do
+        it "calls pre_expedited_exchange hooks with the return items to exchange" do
+          hook = double(:as_null_object)
+          expect(hook).to receive(:call).with [exchange_return_item]
+          subject.class.pre_expedited_exchange_hooks = [hook]
+          subject.save
+        end
+
+        it "attempts to accept all return items requiring exchange" do
+          expect(exchange_return_item).to receive :attempt_accept
+          expect(return_item).not_to receive :attempt_accept
+          subject.save
+        end
+
+        it "performs an exchange reimbursement for the exchange return items" do
+          subject.save
+          reimbursement = Spree::Reimbursement.last
+          expect(reimbursement.order).to eq subject.order
+          expect(reimbursement.return_items).to eq [exchange_return_item]
+          expect(exchange_return_item.reload.exchange_shipment).to be_present
+        end
+
+        context "the reimbursement fails" do
+          before do
+            allow_any_instance_of(Spree::Reimbursement).to receive(:save) { false }
+            allow_any_instance_of(Spree::Reimbursement).to receive(:errors) { double(full_messages: "foo") }
+          end
+
+          it "puts errors on the return authorization" do
+            subject.save
+            expect(subject.errors[:base]).to include "foo"
+          end
+        end
+      end
+
+    end
+  end
+
+  describe ".before_create" do
+    describe "#generate_number" do
+      context "number is assigned" do
+        let(:return_authorization) { Spree::ReturnAuthorization.new(number: '123') }
+
+        it "should return the assigned number" do
+          return_authorization.save
+          expect(return_authorization.number).to eq('123')
+        end
+      end
+
+      context "number is not assigned" do
+        let(:return_authorization) { Spree::ReturnAuthorization.new(number: nil) }
+
+        before { allow(return_authorization).to receive_messages valid?: true }
+
+        it "should assign number with random RA number" do
+          return_authorization.save
+          expect(return_authorization.number).to match(/RA\d{9}/)
+        end
+      end
+    end
+  end
+
+  context "#currency" do
+    before { allow(order).to receive(:currency) { "ABC" } }
+    it "returns the order currency" do
+      expect(return_authorization.currency).to eq("ABC")
+    end
+  end
+
+  describe "#pre_tax_total" do
+    let(:pre_tax_amount_1) { 15.0 }
+    let!(:return_item_1) { create(:return_item, return_authorization: return_authorization, pre_tax_amount: pre_tax_amount_1) }
+
+    let(:pre_tax_amount_2) { 50.0 }
+    let!(:return_item_2) { create(:return_item, return_authorization: return_authorization, pre_tax_amount: pre_tax_amount_2) }
+
+    let(:pre_tax_amount_3) { 5.0 }
+    let!(:return_item_3) { create(:return_item, return_authorization: return_authorization, pre_tax_amount: pre_tax_amount_3) }
+
+    subject { return_authorization.pre_tax_total }
+
+    it "sums it's associated return_item's pre-tax amounts" do
+      expect(subject).to eq (pre_tax_amount_1 + pre_tax_amount_2 + pre_tax_amount_3)
+    end
+  end
+
+  describe "#display_pre_tax_total" do
+    it "returns a Spree::Money" do
+      allow(return_authorization).to receive_messages(pre_tax_total: 21.22)
+      expect(return_authorization.display_pre_tax_total).to eq(Spree::Money.new(21.22))
+    end
+  end
+
+  context "can_receive?" do
+    before do
+      pending "TODO: get this method into our fork"
+    end
+
+    it "should allow_receive when inventory units assigned" do
+      allow(return_authorization).to receive_messages(:inventory_units => [1,2,3])
+      expect(return_authorization.can_receive?).to be true
+    end
+
+    it "should not allow_receive with no inventory units" do
+      allow(return_authorization).to receive_messages(:inventory_units => [])
+      expect(return_authorization.can_receive?).to be false
+    end
+  end
+
+  describe "#refundable_amount" do
+    let(:weighted_line_item_pre_tax_amount) { 5.0 }
+    let(:line_item_count)                   { return_authorization.order.line_items.count }
+
+    subject { return_authorization.refundable_amount }
+
+    before do
+      return_authorization.order.line_items.update_all(pre_tax_amount: weighted_line_item_pre_tax_amount)
+      return_authorization.order.update_attribute(:promo_total, promo_total)
+    end
+
+    context "no promotions" do
+      let(:promo_total) { 0.0 }
+      it "returns the pre-tax line item total" do
+        expect(subject).to eq (weighted_line_item_pre_tax_amount * line_item_count)
+      end
+    end
+
+    context "promotions" do
+      let(:promo_total) { -10.0 }
+      it "returns the pre-tax line item total minus the order level promotion value" do
+        expect(subject).to eq (weighted_line_item_pre_tax_amount * line_item_count) + promo_total
+      end
+    end
+  end
+
+  describe "#customer_returned_items?" do
+    before do
+      allow_any_instance_of(Spree::Order).to receive_messages(return!: true)
+    end
+
+    subject { return_authorization.customer_returned_items? }
+
+    context "has associated customer returns" do
+      let(:customer_return) { create(:customer_return) }
+      let(:return_authorization) { customer_return.return_authorizations.first }
+
+      it "returns true" do
+        expect(subject).to eq true
+      end
+    end
+
+    context "does not have associated customer returns" do
+      let(:return_authorization) { create(:return_authorization) }
+
+      it "returns false" do
+        expect(subject).to eq false
+      end
+    end
+  end
+
+  describe 'cancel_return_items' do
+    let(:return_authorization) { create(:return_authorization, return_items: return_items) }
+    let(:return_items) { [return_item] }
+    let(:return_item) { create(:return_item) }
+
+    subject {
+      return_authorization.cancel!
+    }
+
+    it 'cancels the associated return items' do
+      subject
+      expect(return_item.reception_status).to eq 'cancelled'
+    end
+
+    context 'some return items cannot be cancelled' do
+      let(:return_items) { [return_item, return_item_2] }
+      let(:return_item_2) { create(:return_item, reception_status: 'received') }
+
+      it 'cancels those that can be cancelled' do
+        subject
+        expect(return_item.reception_status).to eq 'cancelled'
+        expect(return_item_2.reception_status).to eq 'received'
+      end
+    end
+  end
+
+  describe '#can_cancel?' do
+    subject { create(:return_authorization, return_items: return_items).can_cancel? }
+    let(:return_items) { [return_item_1, return_item_2] }
+    let(:return_item_1) { create(:return_item) }
+    let(:return_item_2) { create(:return_item) }
+
+    context 'all items can be cancelled' do
+      it 'returns true' do
+        expect(subject).to eq true
+      end
+    end
+
+    context 'at least one return item can be cancelled' do
+      let(:return_item_2) { create(:return_item, reception_status: 'received') }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'no items can be cancelled' do
+      let(:return_item_1) { create(:return_item, reception_status: 'received') }
+      let(:return_item_2) { create(:return_item, reception_status: 'received') }
+
+      it { is_expected.to eq false }
+    end
+
+    context 'when return_authorization has no return_items' do
+      let(:return_items) { [] }
+
+      it { is_expected.to eq true }
+    end
+  end
+end

data/spec/models/spree/return_item/eligibility_validator/default_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Spree::ReturnItem::EligibilityValidator::Default, :type => :model do
+  let(:return_item) { create(:return_item) }
+  let(:validator) { Spree::ReturnItem::EligibilityValidator::Default.new(return_item) }
+
+  let(:time_eligibility_class) { double("TimeEligibilityValidatorClass") }
+  let(:rma_eligibility_class)  { double("RMAEligibilityValidatorClass") }
+
+  let(:time_eligibility_instance) { double(errors: time_error) }
+  let(:rma_eligibility_instance)  { double(errors: rma_error) }
+
+  let(:time_error) {{}}
+  let(:rma_error)  {{}}
+
+  before do
+    validator.permitted_eligibility_validators = [ time_eligibility_class, rma_eligibility_class ]
+
+    expect(time_eligibility_class).to receive(:new).and_return(time_eligibility_instance)
+    expect(rma_eligibility_class).to receive(:new).and_return(rma_eligibility_instance)
+  end
+
+  describe "#eligible_for_return?" do
+    subject { validator.eligible_for_return? }
+
+    it "checks that all permitted eligibility validators are eligible for return" do
+      expect(time_eligibility_instance).to receive(:eligible_for_return?).and_return(true)
+      expect(rma_eligibility_instance).to receive(:eligible_for_return?).and_return(true)
+
+      expect(subject).to be true
+    end
+  end
+
+  describe "#requires_manual_intervention?" do
+    subject { validator.requires_manual_intervention? }
+
+    context "any of the permitted eligibility validators require manual intervention" do
+      it "returns true" do
+        expect(time_eligibility_instance).to receive(:requires_manual_intervention?).and_return(false)
+        expect(rma_eligibility_instance).to receive(:requires_manual_intervention?).and_return(true)
+
+        expect(subject).to be true
+      end
+    end
+
+    context "no permitted eligibility validators require manual intervention" do
+      it "returns false" do
+        expect(time_eligibility_instance).to receive(:requires_manual_intervention?).and_return(false)
+        expect(rma_eligibility_instance).to receive(:requires_manual_intervention?).and_return(false)
+
+        expect(subject).to be false
+      end
+    end
+  end
+
+  describe "#errors" do
+    subject { validator.errors }
+
+    context "the validator errors are empty" do
+      it "returns an empty hash" do
+        expect(subject).to eq({})
+      end
+    end
+
+    context "the validators have errors" do
+      let(:time_error) { { time: time_error_text }}
+      let(:rma_error)  { { rma: rma_error_text }}
+
+      let(:time_error_text) { "Time eligibility error" }
+      let(:rma_error_text)  { "RMA eligibility error" }
+
+      it "gathers all errors from permitted eligibility validators into a single errors hash" do
+        expect(subject).to eq({time: time_error_text, rma: rma_error_text})
+      end
+    end
+  end
+end