solidus_core 1.0.7 → 1.1.0.beta1

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

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

@@ -1,290 +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_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

@@ -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