solidus_core 1.1.0 → 1.1.1

data/spec/lib/tasks/exchanges_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+describe "exchanges:charge_unreturned_items" do
+  let(:task) do
+    Rake::Task['exchanges:charge_unreturned_items']
+  end
+
+  before do
+    Rails.application.load_tasks
+    task.reenable
+  end
+
+  subject { task }
+
+  describe '#prerequisites' do
+    it { expect(subject.prerequisites).to include("environment") }
+  end
+
+  before do
+    @original_expedited_exchanges_pref = Spree::Config[:expedited_exchanges]
+    Spree::Config[:expedited_exchanges] = true
+    Spree::StockItem.update_all(count_on_hand: 10)
+  end
+
+  after { Spree::Config[:expedited_exchanges] = @original_expedited_exchanges_pref }
+
+  context "there are no unreturned items" do
+    it { expect { subject.invoke }.not_to change { Spree::Order.count } }
+  end
+
+  context "there are return items in an intermediate return status" do
+    let!(:order) { create(:shipped_order, line_items_count: 2) }
+    let(:return_item_1) { build(:exchange_return_item, inventory_unit: order.inventory_units.first) }
+    let(:return_item_2) { build(:exchange_return_item, inventory_unit: order.inventory_units.last) }
+    let!(:rma) { create(:return_authorization, order: order, return_items: [return_item_1, return_item_2]) }
+    let!(:tax_rate) { create(:tax_rate, zone: order.tax_zone, tax_category: return_item_2.exchange_variant.tax_category) }
+    before do
+      rma.save!
+      Spree::Shipment.last.ship!
+      return_item_1.lost!
+      return_item_2.give!
+      Timecop.travel (Spree::Config[:expedited_exchanges_days_window] + 1).days
+    end
+    after { Timecop.return }
+    it { expect { subject.invoke }.not_to change { Spree::Order.count } }
+  end
+
+  context "there are unreturned items" do
+    let!(:order) { create(:shipped_order, line_items_count: 2) }
+    let(:return_item_1) { build(:exchange_return_item, inventory_unit: order.inventory_units.first) }
+    let(:return_item_2) { build(:exchange_return_item, inventory_unit: order.inventory_units.last) }
+    let!(:rma) { create(:return_authorization, order: order, return_items: [return_item_1, return_item_2]) }
+    let!(:tax_rate) { create(:tax_rate, zone: order.tax_zone, tax_category: return_item_2.exchange_variant.tax_category) }
+
+    before do
+      rma.save!
+      Spree::Shipment.last.ship!
+      return_item_1.receive!
+      Timecop.travel travel_time
+    end
+
+    after { Timecop.return }
+
+    context "fewer than the config allowed days have passed" do
+      let(:travel_time) { (Spree::Config[:expedited_exchanges_days_window] - 1).days }
+
+      it "does not create a new order" do
+        expect { subject.invoke }.not_to change { Spree::Order.count }
+      end
+    end
+
+    context "more than the config allowed days have passed" do
+
+      let(:travel_time) { (Spree::Config[:expedited_exchanges_days_window] + 1).days }
+
+      it "creates a new completed order" do
+        expect { subject.invoke }.to change { Spree::Order.count }
+        expect(Spree::Order.last).to be_completed
+      end
+
+      it "sets frontend_viewable to false" do
+        subject.invoke
+        expect(Spree::Order.last).not_to be_frontend_viewable
+      end
+
+      it "moves the shipment for the unreturned items to the new order" do
+        subject.invoke
+        new_order = Spree::Order.last
+        expect(new_order.shipments.count).to eq 1
+        expect(return_item_2.reload.exchange_shipment.order).to eq Spree::Order.last
+      end
+
+      it "creates line items on the order for the unreturned items" do
+        subject.invoke
+        expect(Spree::Order.last.line_items.map(&:variant)).to eq [return_item_2.exchange_variant]
+      end
+
+      it "associates the exchanges inventory units with the new line items" do
+        subject.invoke
+        expect(return_item_2.reload.exchange_inventory_unit.try(:line_item).try(:order)).to eq Spree::Order.last
+      end
+
+      it "uses the credit card from the previous order" do
+        subject.invoke
+        new_order = Spree::Order.last
+        expect(new_order.credit_cards).to be_present
+        expect(new_order.credit_cards.first).to eq order.valid_credit_cards.first
+      end
+
+      context "payments" do
+        it "authorizes the order for the full amount of the unreturned items including taxes" do
+          expect { subject.invoke }.to change { Spree::Payment.count }.by(1)
+          new_order = Spree::Order.last
+          expected_amount = return_item_2.reload.exchange_variant.price + new_order.additional_tax_total + new_order.included_tax_total + new_order.shipment_total
+          expect(new_order.total).to eq expected_amount
+          payment = new_order.payments.first
+          expect(payment.amount).to eq expected_amount
+          expect(new_order.item_total).to eq return_item_2.reload.exchange_variant.price
+        end
+
+        context "auto_capture_exchanges is true" do
+          before do
+            @original_auto_capture_exchanges = Spree::Config[:auto_capture_exchanges]
+            Spree::Config[:auto_capture_exchanges] = true
+          end
+
+          after { Spree::Config[:auto_capture_exchanges] = @original_auto_capture_exchanges }
+
+          it 'creates a pending payment' do
+            expect { subject.invoke }.to change { Spree::Payment.count }.by(1)
+            payment = Spree::Payment.last
+            expect(payment).to be_completed
+          end
+        end
+
+        context "auto_capture_exchanges is false" do
+          before do
+            @original_auto_capture_exchanges = Spree::Config[:auto_capture_exchanges]
+            Spree::Config[:auto_capture_exchanges] = false
+          end
+
+          after { Spree::Config[:auto_capture_exchanges] = @original_auto_capture_exchanges }
+
+          it 'captures payment' do
+            expect { subject.invoke }.to change { Spree::Payment.count }.by(1)
+            payment = Spree::Payment.last
+            expect(payment).to be_pending
+          end
+        end
+      end
+
+      it "does not attempt to create a new order for the item more than once" do
+        subject.invoke
+        subject.reenable
+        expect { subject.invoke }.not_to change { Spree::Order.count }
+      end
+
+      it "associates the store of the original order with the exchange order" do
+        store = order.store
+        expect(Spree::Order).to receive(:create!).once.with(hash_including({store_id: store.id})).and_call_original
+        subject.invoke
+      end
+
+      it 'approves the order' do
+        subject.invoke
+        new_order = Spree::Order.last
+        expect(new_order).to be_approved
+        expect(new_order.is_risky?).to eq false
+        expect(new_order.approver_name).to eq "Spree::UnreturnedItemCharger"
+        expect(new_order.approver).to be nil
+      end
+
+      context "there is no card from the previous order" do
+        let!(:credit_card) { create(:credit_card, user: order.user, default: true, gateway_customer_profile_id: "BGS-123") }
+        before { allow_any_instance_of(Spree::Order).to receive(:valid_credit_cards) { [] } }
+
+        it "attempts to use the user's default card" do
+          expect { subject.invoke }.to change { Spree::Payment.count }.by(1)
+          new_order = Spree::Order.last
+          expect(new_order.credit_cards).to be_present
+          expect(new_order.credit_cards.first).to eq credit_card
+        end
+      end
+
+      context "it is unable to authorize the credit card" do
+        before { allow_any_instance_of(Spree::Payment).to receive(:authorize!).and_raise(RuntimeError) }
+
+        it "raises an error with the order" do
+          expect { subject.invoke }.to raise_error(Spree::ChargeUnreturnedItemsFailures)
+        end
+      end
+
+      context "the exchange inventory unit is not shipped" do
+        before { return_item_2.reload.exchange_inventory_unit.update_columns(state: "on hand") }
+        it "does not create a new order" do
+          expect { subject.invoke }.not_to change { Spree::Order.count }
+        end
+      end
+
+      context "the exchange inventory unit has been returned" do
+        before { return_item_2.reload.exchange_inventory_unit.update_columns(state: "returned") }
+        it "does not create a new order" do
+          expect { subject.invoke }.not_to change { Spree::Order.count }
+        end
+      end
+
+      context 'rma for unreturned exchanges' do
+        context 'config to not create' do
+          before { Spree::Config[:create_rma_for_unreturned_exchange] = false }
+
+          it 'does not create rma' do
+            expect { subject.invoke }.not_to change { Spree::ReturnAuthorization.count }
+          end
+        end
+
+        context 'config to create' do
+          before do
+            Spree::Config[:create_rma_for_unreturned_exchange] = true
+          end
+
+          it 'creates with return items' do
+            expect { subject.invoke }.to change { Spree::ReturnAuthorization.count }
+            rma = Spree::ReturnAuthorization.last
+
+            expect(rma.return_items.all?(&:awaiting?)).to be true
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/tasks/migrations/copy_shipped_shipments_to_cartons_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe 'spree:migrations:copy_shipped_shipments_to_cartons' do
+  before do
+    Rails.application.load_tasks
+    task.reenable
+  end
+
+  describe 'up' do
+    let(:task) do
+      Rake::Task['spree:migrations:copy_shipped_shipments_to_cartons:up']
+    end
+
+    # should generate a carton
+    let!(:shipped_shipment) { shipped_order.shipments.first }
+    # should not generate a carton because it's not shipped
+    let!(:unshipped_shipment) { create(:shipment) }
+    # should not generate a carton because it has no inventory units
+    let!(:shipped_shipment_without_units) do
+      shipped_order_without_units.shipments.first
+    end
+    # should not generate a carton because it already has a carton
+    let!(:shipped_and_cartonized_shipment) do
+      shipped_and_cartonized_order.shipments.first
+    end
+
+    let(:shipped_order) { create(:shipped_order, line_items_count: 1, with_cartons: false) }
+
+    let(:shipped_order_without_units) do
+      create(:shipped_order, line_items_count: 1) do |order|
+        order.inventory_units.delete_all
+      end
+    end
+
+    let(:shipped_and_cartonized_order) do
+      create(:order_ready_to_ship, line_items_count: 1).tap do |order|
+        order.shipping.ship_shipment(order.shipments.first)
+      end
+    end
+
+    it 'creates the expected carton' do
+      expect {
+        task.invoke
+      }.to change { Spree::Carton.count }.by(1)
+
+      carton = Spree::Carton.last
+
+      expect(carton).to be_valid
+
+      expect(carton.imported_from_shipment_id).to eq shipped_shipment.id
+      expect(carton.orders).to eq [shipped_order]
+
+      expect(carton.number).to eq "C#{shipped_shipment.number}"
+      expect(carton.stock_location).to eq shipped_shipment.stock_location
+      expect(carton.address).to eq shipped_shipment.address
+      expect(carton.shipping_method).to eq shipped_shipment.shipping_method
+      expect(carton.tracking).to eq shipped_shipment.tracking
+      expect(carton.shipped_at).to eq shipped_shipment.shipped_at
+      expect(carton.created_at).to be_present
+      expect(carton.updated_at).to be_present
+
+      expect(carton.inventory_units).to match_array shipped_shipment.inventory_units
+    end
+
+    describe 'when run a second time' do
+      before do
+        task.invoke
+        task.reenable
+      end
+
+      let!(:second_shipped_shipment) { second_shipped_order.shipments.first }
+
+      let(:second_shipped_order) { create(:shipped_order, line_items_count: 1, with_cartons: false) }
+
+      it 'creates only a carton for the second shipment' do
+        expect {
+          task.invoke
+        }.to change { Spree::Carton.count }.by(1)
+
+        carton = Spree::Carton.last
+
+        expect(carton.imported_from_shipment_id).to eq second_shipped_shipment.id
+        expect(carton.orders).to eq [second_shipped_order]
+      end
+    end
+  end
+
+  describe 'down' do
+    let(:task) do
+      Rake::Task['spree:migrations:copy_shipped_shipments_to_cartons:down']
+    end
+
+    let!(:migrated_carton) { create(:carton) }
+    let!(:preexisting_carton) { create(:carton) }
+
+    let!(:migrated_carton_inventory_units) { migrated_carton.inventory_units.to_a }
+    let!(:preexisting_carton_inventory_units) { preexisting_carton.inventory_units.to_a }
+
+    before do
+      migrated_carton.update!(imported_from_shipment_id: migrated_carton.inventory_units.first.shipment_id)
+    end
+
+    it 'clears out the correct carton' do
+      expect {
+        task.invoke
+      }.to change { Spree::Carton.count }.by(-1)
+
+      expect(Spree::Carton.find_by(id: migrated_carton.id)).to be_nil
+
+      expect(migrated_carton_inventory_units.map(&:reload).map(&:carton_id)).to all(be_nil)
+      expect(preexisting_carton_inventory_units.map(&:reload).map(&:carton_id)).to all(eq preexisting_carton.id)
+    end
+  end
+
+end

data/spec/lib/tasks/order_capturing_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "order_capturing:capture_payments" do
+  let(:task) do
+    Rake::Task['order_capturing:capture_payments']
+  end
+
+  before do
+    Rails.application.load_tasks
+    task.reenable
+  end
+
+  subject { task }
+
+  describe '#prerequisites' do
+    subject { super().prerequisites }
+    it { is_expected.to include("environment") }
+  end
+  let(:order) { create(:completed_order_with_pending_payment, line_items_count: 2) }
+  let(:payment) { order.payments.first }
+
+  context "with a mix of canceled and shipped inventory" do
+    before do
+      Spree::OrderCancellations.new(order).short_ship([order.inventory_units.first])
+      order.shipping.ship_shipment(order.shipments.first)
+      order.update_attributes!(payment_state: 'balance_due')
+    end
+
+    it "charges the order" do
+      expect(order.inventory_units.any?(&:on_hand?)).to eq false
+      expect(order.inventory_units.all? {|iu| iu.canceled? || iu.shipped? }).to eq true
+      expect {
+        expect { subject.invoke }.to change { payment.reload.state }.to('completed')
+      }.to change { order.reload.payment_state }.to('paid')
+    end
+
+    context "when there is an error capturing payment" do
+      before do
+        allow_any_instance_of(Spree::OrderCapturing).to receive(:capture_payments).and_raise(StateMachines::InvalidTransition)
+      end
+
+      it "raises a OrderCapturingFailures" do
+        expect { subject.invoke }.to raise_error(Spree::OrderCapturingFailures)
+      end
+    end
+  end
+
+  context "with any inventory not shipped or canceled" do
+    it "does not charge for the order" do
+      expect(order.inventory_units.any?(&:on_hand?)).to eq true
+      expect {
+        expect { subject.invoke }.not_to change { payment.reload }
+      }.not_to change { order.reload.payment_state }
+    end
+  end
+end

data/spec/mailers/carton_mailer_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'email_spec'
+
+describe Spree::CartonMailer do
+  include EmailSpec::Helpers
+  include EmailSpec::Matchers
+
+  let(:carton) { create(:carton) }
+  let(:order) { carton.orders.first }
+
+  # Regression test for #2196
+  it "doesn't include out of stock in the email body" do
+    shipment_email = Spree::CartonMailer.shipped_email(order: order, carton: carton)
+    expect(shipment_email.body).not_to include(%Q{Out of Stock})
+    expect(shipment_email.body).to include(%Q{Your order has been shipped})
+    expect(shipment_email.subject).to eq "#{order.store.name} Shipment Notification ##{order.number}"
+  end
+
+  context "deprecated signature" do
+    it do
+      ActiveSupport::Deprecation.silence do
+        mail = Spree::CartonMailer.shipped_email(carton.id)
+        expect(mail.subject).to include "Shipment Notification"
+      end
+    end
+  end
+
+  context "with resend option" do
+    subject do
+      Spree::CartonMailer.shipped_email(order: order, carton: carton, resend: true).subject
+    end
+    it { is_expected.to match /^\[RESEND\] / }
+  end
+
+  context "emails must be translatable" do
+    context "shipped_email" do
+      context "pt-BR locale" do
+        before do
+          pt_br_shipped_email = { :spree => { :shipment_mailer => { :shipped_email => { :dear_customer => 'Caro Cliente,' } } } }
+          I18n.backend.store_translations :'pt-BR', pt_br_shipped_email
+          I18n.locale = :'pt-BR'
+        end
+
+        after do
+          I18n.locale = I18n.default_locale
+        end
+
+        specify do
+          shipped_email = Spree::CartonMailer.shipped_email(order: order, carton: carton)
+          expect(shipped_email.body).to include("Caro Cliente,")
+        end
+      end
+    end
+  end
+end