solidus_core 2.10.2 → 2.11.0

data/spec/models/spree/order_merger_spec.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-# Regression tests for https://github.com/spree/spree/issues/2179
-module Spree
-  RSpec.describe OrderMerger, type: :model do
-    let(:variant) { create(:variant) }
-    let!(:store) { create(:store, default: true) }
-    let(:order_1) { Spree::Order.create }
-    let(:order_2) { Spree::Order.create }
-    let(:user) { stub_model(Spree::LegacyUser, email: "spree@example.com") }
-    let(:subject) { Spree::OrderMerger.new(order_1) }
-
-    it "destroys the other order" do
-      subject.merge!(order_2)
-      expect { order_2.reload }.to raise_error(ActiveRecord::RecordNotFound)
-    end
-
-    it "persist the merge" do
-      expect(subject).to receive(:persist_merge)
-      subject.merge!(order_2)
-    end
-
-    context "user is provided" do
-      it "assigns user to new order" do
-        subject.merge!(order_2, user)
-        expect(order_1.user).to eq user
-      end
-    end
-
-    context "merging together two orders with line items for the same variant" do
-      before do
-        order_1.contents.add(variant, 1)
-        order_2.contents.add(variant, 1)
-      end
-
-      specify do
-        subject.merge!(order_2, user)
-        expect(order_1.line_items.count).to eq(1)
-
-        line_item = order_1.line_items.first
-        expect(line_item.quantity).to eq(2)
-        expect(line_item.variant_id).to eq(variant.id)
-      end
-    end
-
-    context 'merging together two orders with multiple currencies line items' do
-      let(:order_2) { Spree::Order.create(currency: 'JPY') }
-      let(:variant_2) { create(:variant) }
-
-      before do
-        Spree::Price.create(variant: variant_2, amount: 10, currency: 'JPY')
-        order_1.contents.add(variant, 1)
-        order_2.contents.add(variant_2.reload, 1)
-      end
-
-      it 'rejects other order line items' do
-        subject.merge!(order_2, user)
-        expect(order_1.line_items.count).to eq(1)
-
-        line_item = order_1.line_items.first
-        expect(line_item.quantity).to eq(1)
-        expect(line_item.variant_id).to eq(variant.id)
-      end
-    end
-
-    context "merging using extension-specific line_item_comparison_hooks" do
-      before do
-        Spree::Order.register_line_item_comparison_hook(:foos_match)
-      end
-
-      after do
-        # reset to avoid test pollution
-        Spree::Order.line_item_comparison_hooks = Set.new
-      end
-
-      context "2 equal line items" do
-        before do
-          @line_item_one = order_1.contents.add(variant, 1, foos: {})
-          @line_item_two = order_2.contents.add(variant, 1, foos: {})
-        end
-
-        specify do
-          without_partial_double_verification do
-            expect(order_1).to receive(:foos_match).with(@line_item_one, kind_of(Hash)).and_return(true)
-          end
-          subject.merge!(order_2)
-          expect(order_1.line_items.count).to eq(1)
-
-          line_item = order_1.line_items.first
-          expect(line_item.quantity).to eq(2)
-          expect(line_item.variant_id).to eq(variant.id)
-        end
-      end
-
-      context "2 different line items" do
-        before do
-          without_partial_double_verification do
-            allow(order_1).to receive(:foos_match).and_return(false)
-          end
-
-          order_1.contents.add(variant, 1, foos: {})
-          order_2.contents.add(variant, 1, foos: { bar: :zoo })
-        end
-
-        specify do
-          subject.merge!(order_2)
-          expect(order_1.line_items.count).to eq(2)
-
-          line_item = order_1.line_items.first
-          expect(line_item.quantity).to eq(1)
-          expect(line_item.variant_id).to eq(variant.id)
-
-          line_item = order_1.line_items.last
-          expect(line_item.quantity).to eq(1)
-          expect(line_item.variant_id).to eq(variant.id)
-        end
-      end
-    end
-
-    context "merging together two orders with different line items" do
-      let(:variant_2) { create(:variant) }
-
-      before do
-        order_1.contents.add(variant, 1)
-        order_2.contents.add(variant_2, 1)
-      end
-
-      specify do
-        subject.merge!(order_2)
-
-        # Both in memory and in DB line items
-        expect(order_1.line_items.length).to eq(2)
-        expect(order_1.line_items.count).to eq(2)
-
-        expect(order_1.item_count).to eq 2
-        expect(order_1.item_total).to eq order_1.line_items.map(&:amount).sum
-
-        # No guarantee on ordering of line items, so we do this:
-        expect(order_1.line_items.pluck(:quantity)).to match_array([1, 1])
-        expect(order_1.line_items.pluck(:variant_id)).to match_array([variant.id, variant_2.id])
-      end
-    end
-
-    context "merging together orders with invalid line items" do
-      let(:variant_2) { create(:variant) }
-
-      before do
-        order_1.contents.add(variant, 1)
-        order_2.contents.add(variant_2, 1)
-      end
-
-      it "should create errors with invalid line items" do
-        variant_2.really_destroy!
-        order_2.line_items.to_a.first.reload # so that it registers as invalid
-        subject.merge!(order_2)
-        expect(order_1.errors.full_messages).not_to be_empty
-      end
-    end
-  end
-end

data/spec/models/spree/order_mutex_spec.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::OrderMutex do
-  include ActiveSupport::Testing::TimeHelpers
-
-  let(:order) { create(:order) }
-
-  context "without an existing lock" do
-    it "executes the block" do
-      expect { |b|
-        Spree::OrderMutex.with_lock!(order, &b)
-      }.to yield_control.once
-    end
-
-    it "releases the lock for subsequent calls" do
-      expect { |b|
-        Spree::OrderMutex.with_lock!(order, &b)
-        Spree::OrderMutex.with_lock!(order, &b)
-      }.to yield_control.twice
-    end
-
-    it "returns the value of the block" do
-      expect(Spree::OrderMutex.with_lock!(order) { 'yay for spree' }).to eq 'yay for spree'
-    end
-  end
-
-  context "with an existing lock on the same order" do
-    it "raises a LockFailed error and then releases the lock" do
-      Spree::OrderMutex.with_lock!(order) do
-        expect {
-          expect { |b|
-            Spree::OrderMutex.with_lock!(order, &b)
-          }.not_to yield_control
-        }.to raise_error(Spree::OrderMutex::LockFailed)
-      end
-
-      expect { |b|
-        Spree::OrderMutex.with_lock!(order, &b)
-      }.to yield_control.once
-    end
-  end
-
-  context "with an expired existing lock on the same order" do
-    around do |example|
-      Spree::OrderMutex.with_lock!(order) do
-        future = Spree::Config[:order_mutex_max_age].seconds.from_now + 1.second
-        travel_to(future) do
-          example.run
-        end
-      end
-    end
-
-    it "executes the block" do
-      expect { |b|
-        Spree::OrderMutex.with_lock!(order, &b)
-      }.to yield_control.once
-    end
-  end
-
-  context "with an existing lock on a different order" do
-    let(:order2) { create(:order) }
-
-    around do |example|
-      Spree::OrderMutex.with_lock!(order2) { example.run }
-    end
-
-    it "executes the block" do
-      expect { |b|
-        Spree::OrderMutex.with_lock!(order, &b)
-      }.to yield_control.once
-    end
-  end
-
-  context "when an unrelated RecordNotUnique error occurs" do
-    def raise_record_not_unique
-      raise ActiveRecord::RecordNotUnique.new("Testing")
-    end
-
-    it "does not rescue the unrelated error" do
-      expect {
-        Spree::OrderMutex.with_lock!(order) do
-          raise_record_not_unique
-        end
-      }.to raise_error(ActiveRecord::RecordNotUnique)
-    end
-  end
-end

data/spec/models/spree/order_promotion_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::OrderPromotion do
-  subject do
-    order_promotion
-  end
-
-  let(:order_promotion) { build(:order_promotion) }
-
-  describe "promotion code presence error" do
-    subject do
-      order_promotion.valid?
-      order_promotion.errors[:promotion_code]
-    end
-
-    let(:order_promotion) { build(:order_promotion) }
-    let(:promotion) { order_promotion.promotion }
-
-    context "when the promotion does not have a code" do
-      it { is_expected.to be_blank }
-    end
-
-    context "when the promotion has a code" do
-      let!(:promotion_code) do
-        promotion.codes << build(:promotion_code, promotion: promotion)
-      end
-
-      it { is_expected.to include("can't be blank") }
-    end
-  end
-end

data/spec/models/spree/order_shipping_spec.rb

@@ -1,247 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::OrderShipping do
-  include ActiveSupport::Testing::TimeHelpers
-
-  let(:order) { create(:order_ready_to_ship, line_items_count: 1) }
-
-  def emails
-    ActionMailer::Base.deliveries
-  end
-
-  shared_examples 'shipment shipping' do
-    it "marks the inventory units as shipped" do
-      expect { subject }.to change { order.inventory_units.reload.map(&:state) }.from(['on_hand']).to(['shipped'])
-    end
-
-    it "creates a carton with the shipment's inventory units" do
-      expect { subject }.to change { order.cartons.count }.by(1)
-      expect(subject.inventory_units).to match_array(shipment.inventory_units)
-    end
-
-    describe "shipment email" do
-      it "should send a shipment email" do
-        expect {
-          perform_enqueued_jobs {
-            subject
-          }
-        }.to change { emails.size }.by(1)
-        expect(emails.last.subject).to eq("#{order.store.name} Shipment Notification ##{order.number}")
-      end
-    end
-
-    it "updates the order shipment state" do
-      expect { subject }.to change { order.reload.shipment_state }.from('ready').to('shipped')
-    end
-
-    it "updates shipment.shipped_at" do
-      now = Time.current
-      travel_to(now) do
-        expect { subject }.to change { shipment.shipped_at }.from(nil).to be_within(1.second).of(now)
-      end
-    end
-
-    it "updates order.updated_at" do
-      future = 1.minute.from_now
-      expect do
-        travel_to(future) do
-          subject
-        end
-      end.to change { order.updated_at }.to be_within(1.second).of(future)
-    end
-  end
-
-  describe "#ship" do
-    subject do
-      order.shipping.ship(
-        inventory_units: inventory_units,
-        stock_location: stock_location,
-        address: address,
-        shipping_method: shipping_method
-      )
-    end
-
-    let(:shipment) { order.shipments.to_a.first }
-    let(:inventory_units) { shipment.inventory_units }
-    let(:stock_location) { shipment.stock_location }
-    let(:address) { order.ship_address }
-    let(:shipping_method) { shipment.shipping_method }
-
-    it_behaves_like 'shipment shipping'
-
-    context "with an external_number" do
-      subject do
-        order.shipping.ship(
-          inventory_units: inventory_units,
-          stock_location: stock_location,
-          address: address,
-          shipping_method: shipping_method,
-          external_number: 'some-external-number'
-        )
-      end
-
-      it "sets the external_number" do
-        expect(subject.external_number).to eq 'some-external-number'
-      end
-    end
-
-    context "with a tracking number" do
-      subject do
-        order.shipping.ship(
-          inventory_units: inventory_units,
-          stock_location: stock_location,
-          address: address,
-          shipping_method: shipping_method,
-          tracking_number: 'tracking-number'
-        )
-      end
-
-      it "sets the tracking-number" do
-        expect(subject.tracking).to eq 'tracking-number'
-      end
-    end
-
-    context "when told to suppress the mailer" do
-      subject do
-        order.shipping.ship(
-          inventory_units: inventory_units,
-          stock_location: stock_location,
-          address: address,
-          shipping_method: shipping_method,
-          suppress_mailer: true
-        )
-      end
-
-      it "does not send a shipment email" do
-        expect { subject }.to_not change { emails.size }
-      end
-    end
-  end
-
-  describe "#ship_shipment" do
-    subject { order.shipping.ship_shipment(shipment) }
-
-    let(:shipment) { order.shipments.to_a.first }
-
-    it_behaves_like 'shipment shipping'
-
-    context "when not all units are shippable" do
-      let(:order) { create(:order_ready_to_ship, line_items_count: 2) }
-      let(:shippable_line_item) { order.line_items.first }
-      let(:unshippable_line_item) { order.line_items.last }
-
-      before do
-        unshippable_line_item.inventory_units.each(&:cancel!)
-      end
-
-      it "only ships the shippable ones" do
-        expect(subject.inventory_units).to match_array(shippable_line_item.inventory_units)
-      end
-    end
-
-    context "when all units are canceled or shipped" do
-      let(:order) { create(:order_ready_to_ship, line_items_count: 2) }
-
-      before { Spree::OrderCancellations.new(order).short_ship([order.inventory_units.first]) }
-
-      it "updates the order shipment state" do
-        expect { subject }.to change { order.reload.shipment_state }.from('ready').to('shipped')
-      end
-    end
-
-    context "with an external_number" do
-      subject do
-        order.shipping.ship_shipment(
-          shipment,
-          external_number: 'some-external-number'
-        )
-      end
-
-      it "sets the external_number" do
-        expect(subject.external_number).to eq 'some-external-number'
-      end
-    end
-
-    context "with a tracking number" do
-      subject do
-        order.shipping.ship_shipment(
-          shipment,
-          tracking_number: 'tracking-number'
-        )
-      end
-
-      it "sets the tracking-number" do
-        expect(subject.tracking).to eq 'tracking-number'
-      end
-    end
-
-    # TODO: We can remove this once Shipment#ship! is called by
-    # OrderShipping#ship rather than vice versa
-    context "when the tracking number is already on the shipment" do
-      before do
-        shipment.update!(tracking: 'tracking-number')
-      end
-
-      it "sets the tracking-number" do
-        expect(subject.tracking).to eq 'tracking-number'
-      end
-    end
-
-    context "when the shipment has been partially shipped previously" do
-      let(:order) { create(:order_ready_to_ship, line_items_count: 2) }
-      let(:inventory_units) { shipment.inventory_units.to_a }
-      let(:shipped_inventory) { [inventory_units.first] }
-      let(:unshipped_inventory) { [inventory_units.last] }
-
-      before do
-        order.shipping.ship(
-          inventory_units: shipped_inventory,
-          stock_location: shipment.stock_location,
-          address: order.ship_address,
-          shipping_method: shipment.shipping_method
-        )
-      end
-
-      it "marks the inventory units as shipped" do
-        expect { subject }.to change { unshipped_inventory.map(&:reload).map(&:state) }.from(['on_hand']).to(['shipped'])
-      end
-
-      it "creates a carton with the shipment's inventory units" do
-        expect { subject }.to change { order.cartons.count }.by(1)
-        expect(subject.inventory_units).to match_array(unshipped_inventory)
-      end
-    end
-
-    context "when told to suppress the mailer" do
-      subject do
-        order.shipping.ship_shipment(
-          shipment,
-          suppress_mailer: true
-        )
-      end
-
-      it "does not send a shipment email" do
-        expect { subject }.to_not change { emails.size }
-      end
-    end
-
-    context "with stale inventory units (regression test)" do
-      let(:order) { FactoryBot.create(:order_ready_to_ship, line_items_count: 1) }
-      let(:shipment) do
-        FactoryBot.create(
-          :shipment,
-          order: order
-        )
-      end
-
-      before { shipment.ready! }
-
-      it "updates the state to shipped" do
-        order.shipping.ship_shipment(shipment)
-        expect(shipment.reload.state).to eq "shipped"
-      end
-    end
-  end
-end