spree_core 3.2.1 → 3.2.2

data/spec/models/spree/property_prototype_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Spree::PropertyPrototype do
-  describe 'Validations' do
-    it { is_expected.to validate_presence_of(:prototype) }
-    it { is_expected.to validate_presence_of(:property) }
-    it { is_expected.to validate_uniqueness_of(:prototype_id).scoped_to(:property_id).allow_nil }
-  end
-end

data/spec/models/spree/property_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Property, type: :model do
-
-end

data/spec/models/spree/prototype_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Prototype, type: :model do
-
-end

data/spec/models/spree/prototype_taxon_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Spree::PrototypeTaxon do
-  describe 'Validations' do
-    it { is_expected.to validate_presence_of(:prototype) }
-    it { is_expected.to validate_presence_of(:taxon) }
-    it { is_expected.to validate_uniqueness_of(:prototype_id).scoped_to(:taxon_id).allow_nil }
-  end
-end

data/spec/models/spree/refund_reason_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe Spree::RefundReason do
-  describe 'Associations' do
-    it { is_expected.to have_many(:refunds).dependent(:restrict_with_error) }
-  end
-
-  describe 'Class Methods' do
-    describe '.return_processing_reason' do
-      context 'default refund reason present' do
-        let!(:default_refund_reason) { create(:default_refund_reason) }
-        it { expect(described_class.return_processing_reason).to eq(default_refund_reason) }
-      end
-
-      context 'default refund reason not present' do
-        it { expect(described_class.return_processing_reason).to eq(nil) }
-      end
-    end
-  end
-end

data/spec/models/spree/refund_spec.rb

@@ -1,195 +0,0 @@
-require 'spec_helper'
-
-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
-        message = double("gateway_error")
-        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(message, nil))
-      end
-
-      it 'raises Spree::Core::GatewayError' do
-        expect { subject }.to raise_error(Spree::Core::GatewayError, Spree.t(: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
-  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) }
-
-    subject { Spree::Refund.total_amount_reimbursed_for(reimbursement) }
-
-    context 'with reimbursements performed' do
-      before { reimbursement.perform! }
-
-      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,36 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  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.new('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,140 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  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,83 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  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