solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/models/spree/order/state_machine_spec.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Order, type: :model do
+  let(:order) { create(:order_with_line_items) }
+
+  context "#next!" do
+    context "when current state is confirm" do
+      before do
+        order.state = "confirm"
+        order.save!
+      end
+
+      context "when payment processing succeeds" do
+        let!(:payment) do
+          create(:payment, state: 'checkout', order: order)
+        end
+
+        it "should finalize order when transitioning to complete state" do
+          order.complete!
+          expect(order).to be_complete
+          expect(order).to be_completed
+        end
+
+        context "when credit card processing fails" do
+          let!(:payment) do
+            create(:payment, :failing, state: 'checkout', order: order)
+          end
+
+          it "should not complete the order" do
+            expect(order.complete).to be false
+            expect(order.state).to eq("confirm")
+          end
+        end
+      end
+    end
+
+    context "when current state is address" do
+      before do
+        order.ensure_updated_shipments
+        order.next!
+        expect(order.all_adjustments).to be_empty
+        expect(order.state).to eq "address"
+      end
+
+      it "adjusts tax rates when transitioning to delivery" do
+        expect(Spree::TaxCalculator::Default).to receive(:new).once.with(order).and_call_original
+        order.next!
+      end
+    end
+  end
+
+  context "#can_cancel?" do
+    let(:order) { create(:completed_order_with_totals) }
+    states = [:pending, :backorder, :ready]
+
+    states.each do |shipment_state|
+      it "should be true if shipment_state is #{shipment_state}" do
+        expect(order).to be_completed
+        order.shipment_state = shipment_state
+
+        expect(order).to be_can_cancel
+      end
+    end
+
+    (Spree::Shipment.state_machine.states.keys - states).each do |shipment_state|
+      it "should be false if shipment_state is #{shipment_state}" do
+        expect(order).to be_completed
+        order.shipment_state = shipment_state
+        expect(order).not_to be_can_cancel
+      end
+    end
+  end
+
+  context "#cancel" do
+    let!(:order) { create(:completed_order_with_totals) }
+    let!(:shipment) { order.shipments.first }
+
+    it "is setup correctly" do
+      expect(order).to be_completed
+      expect(order).to be_complete
+      expect(order).to be_allow_cancel
+    end
+
+    it "should send a cancel email" do
+      perform_enqueued_jobs do
+        order.cancel!
+      end
+
+      mail = ActionMailer::Base.deliveries.last
+      expect(mail.subject).to include "Cancellation"
+    end
+
+    context "resets payment state" do
+      let!(:payment) { create(:payment, order: order, amount: order.total, state: "completed") }
+
+      context "without shipped items" do
+        it "should set payment state to 'void'" do
+          expect { order.cancel! }.to change{ order.reload.payment_state }.to("void")
+        end
+      end
+
+      context "with shipped items" do
+        before do
+          order.shipments[0].ship!
+        end
+
+        it "should not alter the payment state" do
+          expect(order).to_not be_allow_cancel
+          expect(order.cancel).to be false
+          expect(order.payment_state).to eql "paid"
+        end
+      end
+
+      it "should automatically refund all payments" do
+        expect(order).to be_allow_cancel
+        expect { order.cancel! }.to change{ payment.reload.state }.to("void")
+      end
+    end
+  end
+end

data/spec/models/spree/order/totals_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  RSpec.describe Order, type: :model do
+    let(:order) { create(:order) }
+    let(:shirt) { create(:variant) }
+
+    context "adds item to cart and activates promo" do
+      let(:promotion) { Promotion.create name: 'Huhu', apply_automatically: true }
+      let(:calculator) { Calculator::FlatPercentItemTotal.new(preferred_flat_percent: 10) }
+      let!(:action) { Promotion::Actions::CreateAdjustment.create(promotion: promotion, calculator: calculator) }
+
+      before { order.contents.add(shirt, 1) }
+
+      context "item quantity changes" do
+        it "recalculates order adjustments" do
+          expect {
+            order.contents.add(shirt, 3)
+          }.to change { order.adjustments.eligible.pluck(:amount) }
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/order/updating_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Order, type: :model do
+  let(:order) { create(:order) }
+
+  context "#update!" do
+    context "when there are update hooks" do
+      before { Spree::Order.register_update_hook :foo }
+      after { Spree::Order.update_hooks.clear }
+      it "should call each of the update hooks" do
+        expect(order).to receive :foo
+        order.recalculate
+      end
+    end
+  end
+end

data/spec/models/spree/order/validations_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  RSpec.describe Spree::Order, type: :model do
+    context "validations" do
+      # Regression test for https://github.com/spree/spree/issues/2214
+      it "does not return two error messages when email is blank" do
+        order = Spree::Order.new
+        allow(order).to receive_messages(require_email: true)
+        order.valid?
+        expect(order.errors[:email]).to eq(["can't be blank"])
+      end
+    end
+  end
+end

data/spec/models/spree/order_cancellations_spec.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::OrderCancellations do
+  describe "#cancel_unit" do
+    subject { Spree::OrderCancellations.new(order).cancel_unit(inventory_unit) }
+    let(:order) { create(:shipped_order, line_items_count: 1) }
+    let(:inventory_unit) { order.inventory_units.first }
+
+    it "creates a UnitCancel record" do
+      expect { subject }.to change { Spree::UnitCancel.count }.by(1)
+      expect(subject.inventory_unit).to eq inventory_unit
+    end
+
+    it "cancels the inventory unit" do
+      expect { subject }.to change { inventory_unit.state }.to "canceled"
+    end
+
+    context "when a reason is specified" do
+      subject { order.cancellations.cancel_unit(inventory_unit, reason: "some reason") }
+
+      it "sets the reason on the UnitCancel" do
+        expect(subject.reason).to eq("some reason")
+      end
+    end
+
+    context "when a reason is not specified" do
+      it "sets a default reason on the UnitCancel" do
+        expect(subject.reason).to eq Spree::UnitCancel::DEFAULT_REASON
+      end
+    end
+
+    context "when a whodunnit is specified" do
+      subject { order.cancellations.cancel_unit(inventory_unit, whodunnit: "some automated system") }
+
+      it "sets the user on the UnitCancel" do
+        expect(subject.created_by).to eq("some automated system")
+      end
+    end
+
+    context "when a whodunnit is not specified" do
+      it "does not set created_by on the UnitCancel" do
+        expect(subject.created_by).to be_nil
+      end
+    end
+  end
+
+  describe "#reimburse_units" do
+    subject { Spree::OrderCancellations.new(order).reimburse_units(inventory_units) }
+    let(:order) { create(:shipped_order, line_items_count: 2) }
+    let(:inventory_units) { order.inventory_units }
+    let!(:default_refund_reason) { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
+
+    it "creates and performs a reimbursement" do
+      expect { subject }.to change { Spree::Reimbursement.count }.by(1)
+      expect(subject.refunds.size).to eq 1
+    end
+
+    it "creates return items for the inventory units and accepts them" do
+      expect { subject }.to change { Spree::ReturnItem.count }.by(inventory_units.count)
+
+      return_items = subject.return_items
+      expect(return_items.map(&:acceptance_status)).to all eq "accepted"
+      expect(return_items.map(&:inventory_unit)).to match_array(inventory_units)
+    end
+  end
+
+  describe "#short_ship" do
+    subject { Spree::OrderCancellations.new(order).short_ship([inventory_unit]) }
+
+    let(:order) { create(:order_ready_to_ship, line_items_count: 1) }
+    let(:inventory_unit) { order.inventory_units.first }
+    let(:shipment) { inventory_unit.shipment }
+
+    it "creates a UnitCancel record" do
+      expect { subject }.to change { Spree::UnitCancel.count }.by(1)
+
+      unit_cancel = Spree::UnitCancel.last
+      expect(unit_cancel.inventory_unit).to eq inventory_unit
+      expect(unit_cancel.reason).to eq Spree::UnitCancel::SHORT_SHIP
+    end
+
+    it "cancels the inventory unit" do
+      expect { subject }.to change { inventory_unit.state }.to "canceled"
+    end
+
+    it "updates the shipment.state" do
+      expect { subject }.to change { shipment.reload.state }.from('ready').to('shipped')
+    end
+
+    it "updates the order.shipment_state" do
+      expect { subject }.to change { order.shipment_state }.from('ready').to('shipped')
+    end
+
+    it "adjusts the order" do
+      expect { subject }.to change { order.total }.by(-10.0)
+    end
+
+    it "sends a cancellation email" do
+      mail_double = double
+      expect(Spree::OrderMailer).to receive(:inventory_cancellation_email).with(order, [inventory_unit]).and_return(mail_double)
+      expect(mail_double).to receive(:deliver_later)
+      subject
+    end
+
+    context "when send_cancellation_mailer is false" do
+      subject { Spree::OrderCancellations.new(order).short_ship([inventory_unit]) }
+
+      before do
+        @original_send_boolean = Spree::OrderCancellations.send_cancellation_mailer
+        Spree::OrderCancellations.send_cancellation_mailer = false
+      end
+
+      after { Spree::OrderCancellations.send_cancellation_mailer = @original_send_boolean }
+
+      it "does not send a cancellation email" do
+        expect(Spree::OrderMailer).not_to receive(:inventory_cancellation_email)
+        subject
+      end
+    end
+
+    context "with a who" do
+      subject { order.cancellations.short_ship([inventory_unit], whodunnit: 'some automated system') }
+
+      let(:user) { order.user }
+
+      it "sets the user on the UnitCancel" do
+        expect { subject }.to change { Spree::UnitCancel.count }.by(1)
+        expect(Spree::UnitCancel.last.created_by).to eq("some automated system")
+      end
+    end
+
+    context "when rounding is required" do
+      let(:order) { create(:order_ready_to_ship, line_items_count: 1, line_items_price: 0.83) }
+      let(:line_item) { order.line_items.to_a.first }
+      let(:inventory_unit_1) { line_item.inventory_units[0] }
+      let(:inventory_unit_2) { line_item.inventory_units[1] }
+      let(:promotion) { create(:promotion, :with_line_item_adjustment) }
+      let(:promotion_action) { promotion.actions[0] }
+
+      before do
+        order.contents.add(line_item.variant)
+
+        # make the total $1.67 so it divides unevenly
+        line_item.adjustments.create!(
+          order: order,
+          amount: 0.01,
+          label: 'some promo',
+          source: promotion_action,
+          finalized: true,
+        )
+        order.recalculate
+      end
+
+      it "generates the correct total amount" do
+        order.cancellations.short_ship([inventory_unit_1])
+        order.cancellations.short_ship([inventory_unit_2])
+        expect(line_item.adjustments.map(&:amount)).to match_array(
+          [
+            0.01,  # promo adjustment
+            -0.84, # short ship 1
+            -0.83, # short ship 2
+          ]
+        )
+        expect(line_item.total).to eq 0
+      end
+    end
+
+    describe 'short_ship_tax_notifier' do
+      context 'when present' do
+        let(:short_ship_tax_notifier) { double }
+
+        before do
+          @old_notifier = Spree::OrderCancellations.short_ship_tax_notifier
+          Spree::OrderCancellations.short_ship_tax_notifier = short_ship_tax_notifier
+        end
+        after do
+          Spree::OrderCancellations.short_ship_tax_notifier = @old_notifier
+        end
+
+        it 'calls the short_ship_tax_notifier' do
+          expect(short_ship_tax_notifier).to receive(:call) do |unit_cancels|
+            expect(unit_cancels.map(&:inventory_unit)).to match_array([inventory_unit])
+          end
+
+          order.cancellations.short_ship([inventory_unit])
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/order_capturing_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::OrderCapturing do
+  describe '#capture_payments' do
+    subject { Spree::OrderCapturing.new(order).capture_payments }
+
+    let(:order) { build(:completed_order_with_totals) }
+
+    it 'is deprecated' do
+      expect(Spree::Deprecation).to(receive(:warn))
+      subject
+    end
+  end
+end