solidus_core 2.10.0 → 2.11.0

data/spec/models/spree/refund_spec.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Refund, type: :model do
-  describe 'create' do
-    let(:amount) { 100.0 }
-    let(:amount_in_cents) { amount * 100 }
-
-    let(:authorization) { generate(:refund_transaction_id) }
-
-    let(:payment) { create(:payment, amount: payment_amount, payment_method: payment_method) }
-    let(:payment_amount) { amount * 2 }
-    let(:payment_method) { create(:credit_card_payment_method) }
-
-    let(:refund_reason) { create(:refund_reason) }
-
-    let(:gateway_response) {
-      ActiveMerchant::Billing::Response.new(
-        gateway_response_success,
-        gateway_response_message,
-        gateway_response_params,
-        gateway_response_options
-      )
-    }
-    let(:gateway_response_success) { true }
-    let(:gateway_response_message) { "" }
-    let(:gateway_response_params) { {} }
-    let(:gateway_response_options) { {} }
-
-    subject { create(:refund, payment: payment, amount: amount, reason: refund_reason, transaction_id: nil) }
-
-    before do
-      allow(payment.payment_method)
-        .to receive(:credit)
-        .with(amount_in_cents, payment.source, payment.transaction_id, { originator: an_instance_of(Spree::Refund) })
-        .and_return(gateway_response)
-    end
-
-    context "transaction id exists on creation" do
-      let(:transaction_id) { "12kfjas0" }
-      subject { create(:refund, payment: payment, amount: amount, reason: refund_reason, transaction_id: transaction_id) }
-
-      it "creates a refund record" do
-        expect{ subject }.to change { Spree::Refund.count }.by(1)
-      end
-
-      it "maintains the transaction id" do
-        expect(subject.reload.transaction_id).to eq transaction_id
-      end
-
-      it "saves the amount" do
-        expect(subject.reload.amount).to eq amount
-      end
-
-      it "creates a log entry" do
-        expect(subject.log_entries).to be_present
-      end
-
-      it "does not attempt to process a transaction" do
-        expect(payment.payment_method).not_to receive(:credit)
-        subject
-      end
-    end
-
-    context "processing is successful" do
-      let(:gateway_response_options) { { authorization: authorization } }
-
-      it 'should create a refund' do
-        expect{ subject }.to change{ Spree::Refund.count }.by(1)
-      end
-
-      it 'return the newly created refund' do
-        expect(subject).to be_a(Spree::Refund)
-      end
-
-      it 'should save the returned authorization value' do
-        expect(subject.reload.transaction_id).to eq authorization
-      end
-
-      it 'should save the passed amount as the refund amount' do
-        expect(subject.amount).to eq amount
-      end
-
-      it 'should create a log entry' do
-        expect(subject.log_entries).to be_present
-      end
-
-      it "attempts to process a transaction" do
-        expect(payment.payment_method).to receive(:credit).once
-        subject
-      end
-
-      it 'should update the payment total' do
-        expect(payment.order.updater).to receive(:update)
-        subject
-      end
-    end
-
-    context "processing fails" do
-      let(:gateway_response_success) { false }
-      let(:gateway_response_message) { "failure message" }
-
-      it 'should raise error and not create a refund' do
-        expect do
-          expect { subject }.to raise_error(Spree::Core::GatewayError, gateway_response_message)
-        end.to_not change{ Spree::Refund.count }
-      end
-    end
-
-    context 'without payment profiles supported' do
-      before do
-        allow(payment.payment_method).to receive(:payment_profiles_supported?) { false }
-      end
-
-      it 'should not supply the payment source' do
-        expect(payment.payment_method)
-          .to receive(:credit)
-          .with(amount * 100, payment.transaction_id, { originator: an_instance_of(Spree::Refund) })
-          .and_return(gateway_response)
-
-        subject
-      end
-    end
-
-    context 'with payment profiles supported' do
-      before do
-        allow(payment.payment_method).to receive(:payment_profiles_supported?) { true }
-      end
-
-      it 'should supply the payment source' do
-        expect(payment.payment_method)
-          .to receive(:credit)
-          .with(amount_in_cents, payment.source, payment.transaction_id, { originator: an_instance_of(Spree::Refund) })
-          .and_return(gateway_response)
-
-        subject
-      end
-    end
-
-    context 'with an activemerchant gateway connection error' do
-      before do
-        expect(payment.payment_method)
-          .to receive(:credit)
-          .with(amount_in_cents, payment.source, payment.transaction_id, { originator: an_instance_of(Spree::Refund) })
-          .and_raise(ActiveMerchant::ConnectionError.new("foo", nil))
-      end
-
-      it 'raises Spree::Core::GatewayError' do
-        expect { subject }.to raise_error(Spree::Core::GatewayError, I18n.t('spree.unable_to_connect_to_gateway'))
-      end
-    end
-
-    context 'with amount too large' do
-      let(:payment_amount) { 10 }
-      let(:amount) { payment_amount * 2 }
-
-      it 'is invalid' do
-        expect { subject }.to raise_error { |error|
-          expect(error).to be_a(ActiveRecord::RecordInvalid)
-          expect(error.record.errors.full_messages).to eq ["Amount #{I18n.t('activerecord.errors.models.spree/refund.attributes.amount.greater_than_allowed')}"]
-        }
-      end
-    end
-
-    context 'when payment is not present' do
-      let(:refund) { build(:refund, payment: nil) }
-
-      it 'returns a validation error' do
-        expect { refund.save! }.to raise_error 'Validation failed: Payment can\'t be blank'
-      end
-    end
-  end
-
-  describe 'total_amount_reimbursed_for' do
-    let(:customer_return) { reimbursement.customer_return }
-    let(:reimbursement) { create(:reimbursement) }
-    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::Refund.total_amount_reimbursed_for(reimbursement) }
-
-    context 'with reimbursements performed' do
-      before { reimbursement.perform!(created_by: created_by_user) }
-
-      it 'returns the total amount' do
-        amount = Spree::Refund.total_amount_reimbursed_for(reimbursement)
-        expect(amount).to be > 0
-        expect(amount).to eq reimbursement.total
-      end
-    end
-
-    context 'without reimbursements performed' do
-      it 'returns zero' do
-        amount = Spree::Refund.total_amount_reimbursed_for(reimbursement)
-        expect(amount).to eq 0
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.describe Reimbursement::Credit, type: :model do
-    context 'class methods' do
-      describe '.total_amount_reimbursed_for' do
-        subject { Spree::Reimbursement::Credit.total_amount_reimbursed_for(reimbursement) }
-
-        let(:reimbursement) { create(:reimbursement) }
-        let(:credit_double) { double(amount: 99.99) }
-
-        before { allow(reimbursement).to receive(:credits).and_return([credit_double, credit_double]) }
-
-        it 'should sum the amounts of all of the reimbursements credits' do
-          expect(subject).to eq BigDecimal('199.98')
-        end
-      end
-    end
-
-    describe '#description' do
-      let(:credit) { Spree::Reimbursement::Credit.new(amount: 100, creditable: mock_model(Spree::PaymentMethod::Check)) }
-
-      it "should be the creditable's class name" do
-        expect(credit.description).to eq 'Check'
-      end
-    end
-
-    describe '#display_amount' do
-      let(:credit) { Spree::Reimbursement::Credit.new(amount: 100) }
-
-      it 'should be a money object' do
-        expect(credit.display_amount).to eq Spree::Money.new(100, currency: "USD")
-      end
-    end
-  end
-end

data/spec/models/spree/reimbursement/reimbursement_type_engine_spec.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.describe Reimbursement::ReimbursementTypeEngine, type: :model do
-    describe '#calculate_reimbursement_types' do
-      let(:return_item)   { create(:return_item) }
-      let(:return_items)  { [return_item] }
-      let(:reimbursement_type_engine) { Spree::Reimbursement::ReimbursementTypeEngine.new(return_items) }
-      let(:expired_reimbursement_type) { Spree::ReimbursementType::OriginalPayment }
-      let(:override_reimbursement_type) { Spree::ReimbursementType::OriginalPayment.new }
-      let(:preferred_reimbursement_type) { Spree::ReimbursementType::OriginalPayment.new }
-      let(:calculated_reimbursement_types) { subject }
-      let(:all_reimbursement_types) {
-        [
-                                        reimbursement_type_engine.default_reimbursement_type,
-                                        reimbursement_type_engine.exchange_reimbursement_type,
-                                        expired_reimbursement_type,
-                                        override_reimbursement_type,
-                                        preferred_reimbursement_type
-                                    ]
-      }
-
-      subject { reimbursement_type_engine.calculate_reimbursement_types }
-
-      shared_examples_for "reimbursement type hash" do
-        it "contain all keys that respond to reimburse" do
-          calculated_reimbursement_types.keys.each do |r_type|
-            expect(r_type).to respond_to :reimburse
-          end
-        end
-      end
-
-      before do
-        reimbursement_type_engine.expired_reimbursement_type = expired_reimbursement_type
-        allow(return_item.inventory_unit.shipment).to receive(:shipped_at).and_return(Date.yesterday)
-        allow(return_item).to receive(:exchange_required?).and_return(false)
-      end
-
-      context 'the return item requires exchange' do
-        before { allow(return_item).to receive(:exchange_required?).and_return(true) }
-
-        it 'returns a hash with the exchange reimbursement type associated to the return items' do
-          expect(calculated_reimbursement_types[reimbursement_type_engine.exchange_reimbursement_type]).to eq(return_items)
-        end
-
-        it 'the return items are not included in any of the other reimbursement types' do
-          (all_reimbursement_types - [reimbursement_type_engine.exchange_reimbursement_type]).each do |r_type|
-            expect(calculated_reimbursement_types[r_type]).to eq([])
-          end
-        end
-
-        it_should_behave_like 'reimbursement type hash'
-      end
-
-      context 'the return item does not require exchange' do
-        context 'the return item has an override reimbursement type' do
-          before { allow(return_item).to receive(:override_reimbursement_type).and_return(override_reimbursement_type) }
-
-          it 'returns a hash with the override reimbursement type associated to the return items' do
-            expect(calculated_reimbursement_types[override_reimbursement_type.class]).to eq(return_items)
-          end
-
-          it 'the return items are not included in any of the other reimbursement types' do
-            (all_reimbursement_types - [override_reimbursement_type.class]).each do |r_type|
-              expect(calculated_reimbursement_types[r_type]).to eq([])
-            end
-          end
-
-          it_should_behave_like 'reimbursement type hash'
-        end
-
-        context 'the return item does not have an override reimbursement type' do
-          context 'the return item has a preferred reimbursement type' do
-            before { allow(return_item).to receive(:preferred_reimbursement_type).and_return(preferred_reimbursement_type) }
-
-            context 'the reimbursement type is not valid for the return item' do
-              before { expect(reimbursement_type_engine).to receive(:valid_preferred_reimbursement_type?).and_return(false) }
-
-              it 'returns a hash with no return items associated to the preferred reimbursement type' do
-                expect(calculated_reimbursement_types[preferred_reimbursement_type]).to eq([])
-              end
-
-              it 'the return items are not included in any of the other reimbursement types' do
-                (all_reimbursement_types - [preferred_reimbursement_type]).each do |r_type|
-                  expect(calculated_reimbursement_types[r_type]).to eq([])
-                end
-              end
-
-              it_should_behave_like 'reimbursement type hash'
-            end
-
-            context 'the reimbursement type is valid for the return item' do
-              it 'returns a hash with the expired reimbursement type associated to the return items' do
-                expect(calculated_reimbursement_types[preferred_reimbursement_type.class]).to eq(return_items)
-              end
-
-              it 'the return items are not included in any of the other reimbursement types' do
-                (all_reimbursement_types - [preferred_reimbursement_type.class]).each do |r_type|
-                  expect(calculated_reimbursement_types[r_type]).to eq([])
-                end
-              end
-
-              it_should_behave_like 'reimbursement type hash'
-            end
-          end
-
-          context 'the return item does not have a preferred reimbursement type' do
-            context 'the return item is past the time constraint' do
-              before { allow(reimbursement_type_engine).to receive(:past_reimbursable_time_period?).and_return(true) }
-
-              it 'returns a hash with the expired reimbursement type associated to the return items' do
-                expect(calculated_reimbursement_types[expired_reimbursement_type]).to eq(return_items)
-              end
-
-              it 'the return items are not included in any of the other reimbursement types' do
-                (all_reimbursement_types - [expired_reimbursement_type]).each do |r_type|
-                  expect(calculated_reimbursement_types[r_type]).to eq([])
-                end
-              end
-
-              it_should_behave_like 'reimbursement type hash'
-            end
-
-            context 'the return item is within the time constraint' do
-              it 'returns a hash with the default reimbursement type associated to the return items' do
-                expect(calculated_reimbursement_types[reimbursement_type_engine.default_reimbursement_type]).to eq(return_items)
-              end
-
-              it 'the return items are not included in any of the other reimbursement types' do
-                (all_reimbursement_types - [reimbursement_type_engine.default_reimbursement_type]).each do |r_type|
-                  expect(calculated_reimbursement_types[r_type]).to eq([])
-                end
-              end
-
-              it_should_behave_like 'reimbursement type hash'
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/reimbursement/reimbursement_type_validator_spec.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  RSpec.describe Reimbursement::ReimbursementTypeValidator, type: :model do
-    class DummyClass
-      include Spree::Reimbursement::ReimbursementTypeValidator
-
-      class_attribute :expired_reimbursement_type
-      self.expired_reimbursement_type = Spree::ReimbursementType::Credit
-
-      class_attribute :refund_time_constraint
-      self.refund_time_constraint = 90.days
-    end
-
-    let(:return_item) do
-      create(
-        :return_item,
-        preferred_reimbursement_type: preferred_reimbursement_type
-      )
-    end
-    let(:dummy) { DummyClass.new }
-    let(:preferred_reimbursement_type) { Spree::ReimbursementType::Credit.new }
-
-    describe '#valid_preferred_reimbursement_type?' do
-      before do
-        allow(dummy).to receive(:past_reimbursable_time_period?).and_return(true)
-      end
-
-      subject { dummy.valid_preferred_reimbursement_type?(return_item) }
-
-      context 'is valid' do
-        it 'if it is not past the reimbursable time period' do
-          allow(dummy).to receive(:past_reimbursable_time_period?).and_return(false)
-          expect(subject).to be true
-        end
-
-        it 'if the return items preferred method of reimbursement is the expired method of reimbursement' do
-          expect(subject).to be true
-        end
-      end
-
-      context 'is invalid' do
-        it 'if the return item is past the eligible time period and the preferred method of reimbursement is not the expired method of reimbursement' do
-          return_item.preferred_reimbursement_type =
-            Spree::ReimbursementType::OriginalPayment.new
-          expect(subject).to be false
-        end
-      end
-    end
-
-    describe '#past_reimbursable_time_period?' do
-      subject { dummy.past_reimbursable_time_period?(return_item) }
-
-      before do
-        allow(return_item).to receive_message_chain(:inventory_unit, :shipment, :shipped_at).and_return(shipped_at)
-      end
-
-      context 'it has not shipped' do
-        let(:shipped_at) { nil }
-
-        it 'is not past the reimbursable time period' do
-          expect(subject).to be_falsey
-        end
-      end
-
-      context 'it has shipped and it is more recent than the time constraint' do
-        let(:shipped_at) { (dummy.refund_time_constraint - 1.day).ago }
-
-        it 'is not past the reimbursable time period' do
-          expect(subject).to be false
-        end
-      end
-
-      context 'it has shipped and it is further in the past than the time constraint' do
-        let(:shipped_at) { (dummy.refund_time_constraint + 1.day).ago }
-
-        it 'is past the reimbursable time period' do
-          expect(subject).to be true
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/reimbursement_performer_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.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] } }
-  let(:created_by_user) { create(:user, email: 'user@email.com') }
-
-  before do
-    expect(Spree::ReimbursementPerformer).to receive(:calculate_reimbursement_types).and_return(reimbursement_type_hash)
-  end
-
-  describe ".simulate" do
-    subject { Spree::ReimbursementPerformer.simulate(reimbursement, created_by: created_by_user) }
-
-    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, created_by: created_by_user)
-      subject
-    end
-  end
-
-  describe '.perform' do
-    subject { Spree::ReimbursementPerformer.perform(reimbursement, created_by: created_by_user) }
-
-    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, created_by: created_by_user)
-      subject
-    end
-  end
-end