spree_core 3.2.9 → 3.3.0.rc1

data/spec/models/spree/property_prototype_spec.rb

@@ -0,0 +1,9 @@
+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) }
+  end
+end

data/spec/models/spree/property_spec.rb

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

data/spec/models/spree/prototype_spec.rb

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

data/spec/models/spree/prototype_taxon_spec.rb

@@ -0,0 +1,9 @@
+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) }
+  end
+end

data/spec/models/spree/refund_reason_spec.rb

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

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

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

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

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