solidus_core 2.10.1 → 2.11.2

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

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.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) }
-    let(:created_by_user) { create(:user, email: 'user@email.com') }
-
-    subject { Spree::ReimbursementType::OriginalPayment.reimburse(reimbursement, [return_item], simulate, created_by: created_by_user) }
-
-    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
-
-      context "multiple payment methods" do
-        let(:simulate) { true }
-        let!(:check_payment) { create(:check_payment, order: reimbursement.order, amount: 5.0, state: "completed") }
-        let(:payment) { reimbursement.order.payments.detect { |item| item.payment_method.is_a? Spree::PaymentMethod::BogusCreditCard } }
-        let(:refund_amount) { 10.0 }
-
-        let(:refund_payment_methods) { subject.map { |refund| refund.payment.payment_method } }
-
-        before do
-          reimbursement.order.payments.first.update!(amount: 5.0)
-          return_item.update!(amount: refund_amount)
-        end
-
-        it "includes refunds all payment type" do
-          expect(refund_payment_methods).to include payment.payment_method
-          expect(refund_payment_methods).to include check_payment.payment_method
-        end
-
-        context "filtering payment methods" do
-          around do |example|
-            original = described_class.eligible_refund_methods
-            described_class.eligible_refund_methods = [check_payment.payment_method.class]
-            example.run
-            described_class.eligible_refund_methods = original
-          end
-
-          it "does not refund to ineligible payment methods" do
-            expect(refund_payment_methods).to eq [check_payment.payment_method]
-          end
-        end
-
-        context "sorting payment methods" do
-          around do |example|
-            original = described_class.eligible_refund_methods
-            described_class.eligible_refund_methods = [check_payment.payment_method.class, payment.payment_method.class]
-            example.run
-            described_class.eligible_refund_methods = original
-          end
-
-          it "respects configured payment type sort order" do
-            expect(refund_payment_methods).to eq [check_payment.payment_method, payment.payment_method]
-          end
-
-          context "only one refund is necessary" do
-            let(:refund_amount) { 4.0 }
-            it "only returns refunds to satisfy the refund amount" do
-              expect(refund_payment_methods).to eq [check_payment.payment_method]
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.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: 'user@email.com') }
-    let!(:default_reimbursement_category) { create(:store_credit_category) }
-
-    subject { Spree::ReimbursementType::StoreCredit.reimburse(reimbursement, [return_item, return_item2], simulate, created_by: created_by_user) }
-
-    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
-
-          context 'without a user with email address "spree@example.com" in the database' do
-            before do
-              default_user = Spree::LegacyUser.find_by(email: "spree@example.com")
-              default_user.destroy if default_user
-            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
-end

data/spec/models/spree/return_authorization_spec.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.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
-  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 "#total_excluding_vat" do
-    let(:amount_1) { 15.0 }
-    let!(:return_item_1) { create(:return_item, return_authorization: return_authorization, amount: amount_1) }
-
-    let(:amount_2) { 50.0 }
-    let!(:return_item_2) { create(:return_item, return_authorization: return_authorization, amount: amount_2) }
-
-    let(:amount_3) { 5.0 }
-    let!(:return_item_3) { create(:return_item, return_authorization: return_authorization, amount: amount_3) }
-
-    subject { return_authorization.reload.total_excluding_vat }
-
-    it "sums it's associated return_item's amounts" do
-      expect(subject).to eq(amount_1 + amount_2 + amount_3)
-    end
-  end
-
-  describe "#display_total_excluding_vat" do
-    it "returns a Spree::Money" do
-      allow(return_authorization).to receive_messages(total_excluding_vat: 21.22)
-      expect(return_authorization.display_total_excluding_vat).to eq(Spree::Money.new(21.22))
-    end
-  end
-
-  describe "#amount" do
-    let(:return_item1) { create(:return_item, amount: 10) }
-    let(:return_item2) { create(:return_item, amount: 5) }
-    let(:return_authorization) { create(:return_authorization, return_items: [return_item1, return_item2]) }
-
-    subject { return_authorization.amount }
-
-    it "sums the return items' amounts" do
-      expect(subject).to eq(15)
-    end
-  end
-
-  describe "#refundable_amount" do
-    let(:line_item_price) { 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(price: line_item_price)
-      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(line_item_price * 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((line_item_price * 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,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.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