solidus_core 2.10.1 → 2.11.2

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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Order, type: :model do
-  let(:order) { stub_model('Spree::Order') }
-
-  describe ".is_risky?" do
-    context "Not risky order" do
-      let(:order) { FactoryBot.create(:order, payments: [payment]) }
-      context "with avs_response == D" do
-        let(:payment) { FactoryBot.create(:payment, avs_response: "D") }
-        it "is not considered risky" do
-          expect(order.is_risky?).to eq(false)
-        end
-      end
-
-      context "with avs_response == M" do
-        let(:payment) { FactoryBot.create(:payment, avs_response: "M") }
-        it "is not considered risky" do
-          expect(order.is_risky?).to eq(false)
-        end
-      end
-
-      context "with avs_response == ''" do
-        let(:payment) { FactoryBot.create(:payment, avs_response: "") }
-        it "is not considered risky" do
-          expect(order.is_risky?).to eq(false)
-        end
-      end
-
-      context "with cvv_response_code == M" do
-        let(:payment) { FactoryBot.create(:payment, cvv_response_code: "M") }
-        it "is not considered risky" do
-          expect(order.is_risky?).to eq(false)
-        end
-      end
-
-      context "with cvv_response_message == ''" do
-        let(:payment) { FactoryBot.create(:payment, cvv_response_message: "") }
-        it "is not considered risky" do
-          expect(order.is_risky?).to eq(false)
-        end
-      end
-    end
-
-    context "Risky order" do
-      context "AVS response message" do
-        let(:order) { FactoryBot.create(:order, payments: [FactoryBot.create(:payment, avs_response: "A")]) }
-        it "returns true if the order has an avs_response" do
-          expect(order.is_risky?).to eq(true)
-        end
-      end
-
-      context "CVV response code" do
-        let(:order) { FactoryBot.create(:order, payments: [FactoryBot.create(:payment, cvv_response_code: "N")]) }
-        it "returns true if the order has an cvv_response_code" do
-          expect(order.is_risky?).to eq(true)
-        end
-      end
-
-      context "state == 'failed'" do
-        let(:order) { FactoryBot.create(:order, payments: [FactoryBot.create(:payment, state: 'failed')]) }
-        it "returns true if the order has state == 'failed'" do
-          expect(order.is_risky?).to eq(true)
-        end
-      end
-    end
-  end
-end

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

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

@@ -1,26 +0,0 @@
-# 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/validations_spec.rb

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

@@ -1,233 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::OrderCancellations do
-  describe "#cancel_unit" do
-    subject { described_class.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 and print a deprecation" do
-        expect(Spree::Deprecation).to receive(:warn)
-        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
-
-    context "when a created_by is specified" do
-      subject { order.cancellations.cancel_unit(inventory_unit, created_by: "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 created_by 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 { described_class.new(order).reimburse_units(inventory_units, created_by: created_by_user) }
-    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) }
-    let(:created_by_user) { create(:user, email: 'user@email.com') }
-
-    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 { described_class.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.reload.total }.by(-10.0)
-    end
-
-    context "multiple inventory units" do
-      subject { described_class.new(order).short_ship(inventory_units) }
-
-      let(:quantity) { 4 }
-      let!(:order) { create(:order_with_line_items, line_items_attributes: [{ quantity: quantity }]) }
-      let(:inventory_units) { Spree::InventoryUnit.find(order.line_items.first.inventory_units.pluck(:id)) }
-
-      it "adjusts the order" do
-        expect { subject }.to change { order.reload.total }.by(-40.0)
-      end
-    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 { described_class.new(order).short_ship([inventory_unit]) }
-
-      before do
-        @original_send_boolean = described_class.send_cancellation_mailer
-        described_class.send_cancellation_mailer = false
-      end
-
-      after { described_class.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 "when a created_by is specified" do
-      subject { order.cancellations.short_ship([inventory_unit], created_by: '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 a whodunnit is specified" do
-      subject { order.cancellations.short_ship([inventory_unit], whodunnit: 'some automated system') }
-
-      let(:user) { order.user }
-
-      it "sets the user on the UnitCancel and raises a deprecation # WARNING: " do
-        expect(Spree::Deprecation).to receive(:warn)
-
-        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 = described_class.short_ship_tax_notifier
-          described_class.short_ship_tax_notifier = short_ship_tax_notifier
-        end
-        after do
-          described_class.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