spree_core 3.2.1 → 3.2.2

data/spec/models/spree/return_authorization_reason_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe Spree::ReturnAuthorizationReason do
-  describe 'Associations' do
-    it { is_expected.to have_many(:return_authorizations).dependent(:restrict_with_error) }
-  end
-end

data/spec/models/spree/return_authorization_spec.rb

@@ -1,230 +0,0 @@
-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_authorization_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_authorization_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
-      return_authorization.save
-      expect(return_authorization.errors[:order]).to eq(["has no shipped units"])
-    end
-
-    context "expedited exchanges are configured" do
-      let(:order)                { create(:shipped_order, line_items_count: 2) }
-      let(:exchange_return_item) { create(:exchange_return_item, inventory_unit: order.inventory_units.first) }
-      let(:return_item)          { create(: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 'whitelisted_ransackable_attributes' do
-    it { expect(Spree::ReturnAuthorization.whitelisted_ransackable_attributes).to eq(%w(memo number state)) }
-  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
-
-  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 { should 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 { should eq false }
-    end
-
-    context 'when return_authorization has no return_items' do
-      let(:return_items) { [] }
-
-      it { should eq true }
-    end
-  end
-end

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

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

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

@@ -1,58 +0,0 @@
-require 'spec_helper'
-
-describe Spree::ReturnItem::EligibilityValidator::InventoryShipped do
-  let(:return_item) { create(:return_item) }
-  let(:validator)   { Spree::ReturnItem::EligibilityValidator::InventoryShipped.new(return_item) }
-
-  describe "#eligible_for_return?" do
-    before { allow(return_item.inventory_unit).to receive(:shipped?).and_return(true) }
-
-    subject { validator.eligible_for_return? }
-
-    context "the associated inventory unit is shipped" do
-      it "returns true" do
-        expect(subject).to eq true
-      end
-    end
-
-    context "the associated inventory unit is not shipped" do
-      before { allow(return_item.inventory_unit).to receive(:shipped?).and_return(false) }
-
-      it "returns false" do
-        expect(subject).to eq false
-      end
-
-      it "sets an error" do
-        subject
-        expect(validator.errors[:inventory_unit_shipped]).to eq Spree.t('return_item_inventory_unit_ineligible')
-      end
-    end
-  end
-
-  describe "#requires_manual_intervention?" do
-    subject { validator.requires_manual_intervention? }
-
-    context "not eligible for return" do
-      before do
-        allow(return_item.inventory_unit).to receive(:shipped?).and_return(false)
-        validator.eligible_for_return?
-      end
-
-      it 'returns true if errors were added' do
-        expect(subject).to eq true
-      end
-    end
-
-    context "eligible for return" do
-      before do
-        allow(return_item.inventory_unit).to receive(:shipped?).and_return(true)
-        validator.eligible_for_return?
-      end
-
-      it 'returns false if no errors were added' do
-        expect(subject).to eq false
-      end
-    end
-
-  end
-end

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

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe Spree::ReturnItem::EligibilityValidator::NoReimbursements do
-  let(:validator) { Spree::ReturnItem::EligibilityValidator::NoReimbursements.new(return_item) }
-
-  describe "#eligible_for_return?" do
-
-    subject { validator.eligible_for_return? }
-
-    context "inventory unit has already been reimbursed" do
-      let(:reimbursement) { create(:reimbursement) }
-      let(:return_item)   { reimbursement.return_items.last }
-
-      it "returns false" do
-        expect(subject).to eq false
-      end
-
-      it "sets an error" do
-        subject
-        expect(validator.errors[:inventory_unit_reimbursed]).to eq Spree.t('return_item_inventory_unit_reimbursed')
-      end
-    end
-
-    context "inventory unit has not been reimbursed" do
-      let(:return_item) { create(:return_item) }
-
-      it "returns true" do
-        expect(subject).to eq true
-      end
-    end
-  end
-
-  describe "#requires_manual_intervention?" do
-    subject { validator.requires_manual_intervention? }
-
-    context "not eligible for return" do
-      let(:reimbursement) { create(:reimbursement) }
-      let(:return_item)   { reimbursement.return_items.last }
-
-      before do
-        validator.eligible_for_return?
-      end
-
-      it 'returns true if errors were added' do
-        expect(subject).to eq true
-      end
-    end
-
-    context "eligible for return" do
-      let(:return_item) { create(:return_item) }
-
-      before do
-        validator.eligible_for_return?
-      end
-
-      it 'returns false if no errors were added' do
-        expect(subject).to eq false
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe Spree::ReturnItem::EligibilityValidator::OrderCompleted do
-  let(:inventory_unit) { create(:inventory_unit, order: order) }
-  let(:return_item)    { create(:return_item, inventory_unit: inventory_unit) }
-  let(:validator)      { Spree::ReturnItem::EligibilityValidator::OrderCompleted.new(return_item) }
-
-  describe "#eligible_for_return?" do
-    subject { validator.eligible_for_return? }
-
-    context "the order was completed" do
-      let(:order) { create(:completed_order_with_totals) }
-
-      it "returns true" do
-        expect(subject).to be true
-      end
-    end
-
-    context "the order is not completed" do
-      let(:order) { create(:order) }
-
-      it "returns false" do
-        expect(subject).to be false
-      end
-
-      it "sets an error" do
-        subject
-        expect(validator.errors[:order_not_completed]).to eq Spree.t('return_item_order_not_completed')
-      end
-    end
-  end
-end