solidus_core 2.10.2 → 2.11.0

data/spec/models/spree/stock/location_sorter/default_first_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    module LocationSorter
-      RSpec.describe DefaultFirst, type: :model do
-        subject { described_class.new(stock_locations) }
-
-        let!(:first_stock_location) { create(:stock_location, default: false) }
-        let!(:second_stock_location) { create(:stock_location, default: true) }
-        let(:stock_locations) { Spree::StockLocation.all }
-        let(:sorted_stock_locations) { stock_locations.reverse }
-
-        it 'returns the default stock location first' do
-          expect(subject.sort).to eq(sorted_stock_locations)
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/stock/location_sorter/unsorted_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    module LocationSorter
-      RSpec.describe Unsorted, type: :model do
-        subject { described_class.new(stock_locations) }
-
-        let!(:first_stock_location) { create(:stock_location) }
-        let!(:second_stock_location) { create(:stock_location) }
-        let(:stock_locations) { Spree::StockLocation.all }
-
-        it 'returns the original stock locations unsorted' do
-          expect(subject.sort).to eq(stock_locations)
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/stock/package_spec.rb

@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    RSpec.describe Package, type: :model do
-      let(:variant) { build(:variant, weight: 25.0) }
-      let(:stock_location) { build(:stock_location) }
-      let(:order) { build(:order) }
-      let(:line_item) { build(:line_item, order: order) }
-
-      subject { Package.new(stock_location) }
-
-      def build_inventory_unit
-        build(:inventory_unit, variant: variant, line_item: line_item)
-      end
-
-      it 'calculates the weight of all the contents' do
-        4.times { subject.add build_inventory_unit }
-        expect(subject.weight).to eq(100.0)
-      end
-
-      it 'filters by on_hand and backordered' do
-        4.times { subject.add build_inventory_unit }
-        3.times { subject.add build_inventory_unit, :backordered }
-        expect(subject.on_hand.count).to eq 4
-        expect(subject.backordered.count).to eq 3
-      end
-
-      it 'calculates the quantity by state' do
-        4.times { subject.add build_inventory_unit }
-        3.times { subject.add build_inventory_unit, :backordered }
-
-        expect(subject.quantity).to eq 7
-        expect(subject.quantity(:on_hand)).to eq 4
-        expect(subject.quantity(:backordered)).to eq 3
-      end
-
-      it 'returns nil for content item not found' do
-        unit = build_inventory_unit
-        item = subject.find_item(unit, :on_hand)
-        expect(item).to be_nil
-      end
-
-      it 'finds content item for an inventory unit' do
-        unit = build_inventory_unit
-        subject.add unit
-        item = subject.find_item(unit, :on_hand)
-        expect(item.quantity).to eq 1
-      end
-
-      it 'builds the correct list of shipping methods based on stock location and categories' do
-        category_one = create(:shipping_category)
-        category_two = create(:shipping_category)
-        method_one   = create(:shipping_method, available_to_all: true)
-        method_two   = create(:shipping_method, stock_locations: [stock_location])
-        method_one.shipping_categories = [category_one, category_two]
-        method_two.shipping_categories = [category_one, category_two]
-        variant_one = mock_model(Variant, shipping_category_id: category_one.id)
-        variant_two = mock_model(Variant, shipping_category_id: category_two.id)
-        variant_three = mock_model(Variant, shipping_category_id: nil)
-        contents = [ContentItem.new(build(:inventory_unit, variant: variant_one)),
-                    ContentItem.new(build(:inventory_unit, variant: variant_one)),
-                    ContentItem.new(build(:inventory_unit, variant: variant_two)),
-                    ContentItem.new(build(:inventory_unit, variant: variant_three))]
-
-        package = Package.new(stock_location, contents)
-        expect(package.shipping_methods).to match_array([method_one, method_two])
-      end
-      # Contains regression test for https://github.com/spree/spree/issues/2804
-      it 'builds a list of shipping methods common to all categories' do
-        category_one = create(:shipping_category)
-        category_two = create(:shipping_category)
-        method_one   = create(:shipping_method)
-        method_two   = create(:shipping_method)
-        method_one.shipping_categories = [category_one, category_two]
-        method_two.shipping_categories = [category_one]
-        variant_one = mock_model(Variant, shipping_category_id: category_one.id)
-        variant_two = mock_model(Variant, shipping_category_id: category_two.id)
-        variant_three = mock_model(Variant, shipping_category_id: nil)
-        contents = [ContentItem.new(build(:inventory_unit, variant: variant_one)),
-                    ContentItem.new(build(:inventory_unit, variant: variant_one)),
-                    ContentItem.new(build(:inventory_unit, variant: variant_two)),
-                    ContentItem.new(build(:inventory_unit, variant: variant_three))]
-
-        package = Package.new(stock_location, contents)
-        expect(package.shipping_methods).to match_array([method_one])
-      end
-
-      it 'builds an empty list of shipping methods when no categories' do
-        variant  = mock_model(Variant, shipping_category_id: nil)
-        contents = [ContentItem.new(build(:inventory_unit, variant: variant))]
-        package  = Package.new(stock_location, contents)
-        expect(package.shipping_methods).to be_empty
-      end
-
-      it "can convert to a shipment" do
-        2.times { subject.add build_inventory_unit }
-        subject.add build_inventory_unit, :backordered
-
-        shipping_method = build(:shipping_method)
-
-        shipment = subject.to_shipment
-        shipment.shipping_rates = [Spree::ShippingRate.new(shipping_method: shipping_method, cost: 10.00, selected: true)]
-        expect(shipment.stock_location).to eq subject.stock_location
-        expect(shipment.inventory_units.size).to eq 3
-
-        first_unit = shipment.inventory_units.first
-        expect(first_unit.variant).to eq variant
-        expect(first_unit.state).to eq 'on_hand'
-        expect(first_unit).to be_pending
-
-        last_unit = shipment.inventory_units.last
-        expect(last_unit.variant).to eq variant
-        expect(last_unit.state).to eq 'backordered'
-
-        expect(shipment.shipping_method).to eq shipping_method
-      end
-
-      it 'does not add an inventory unit to a package twice' do
-        # since inventory units currently don't have a quantity
-        unit = build_inventory_unit
-        subject.add unit
-        subject.add unit
-        expect(subject.quantity).to eq 1
-        expect(subject.contents.first.inventory_unit).to eq unit
-        expect(subject.contents.first.quantity).to eq 1
-      end
-
-      describe "#add_multiple" do
-        it "adds multiple inventory units" do
-          expect { subject.add_multiple [build_inventory_unit, build_inventory_unit] }.to change { subject.quantity }.by(2)
-        end
-
-        it "allows adding with a state" do
-          expect { subject.add_multiple [build_inventory_unit, build_inventory_unit], :backordered }.to change { subject.backordered.count }.by(2)
-        end
-
-        it "defaults to adding with the on hand state" do
-          expect { subject.add_multiple [build_inventory_unit, build_inventory_unit] }.to change { subject.on_hand.count }.by(2)
-        end
-      end
-
-      describe "#remove" do
-        let(:unit) { build_inventory_unit }
-        context "there is a content item for the inventory unit" do
-          before { subject.add unit }
-
-          it "removes that content item" do
-            expect { subject.remove(unit) }.to change { subject.quantity }.by(-1)
-            expect(subject.contents.map(&:inventory_unit)).not_to include unit
-          end
-        end
-
-        context "there is no content item for the inventory unit" do
-          it "doesn't change the set of content items" do
-            expect { subject.remove(unit) }.not_to change { subject.quantity }
-          end
-        end
-      end
-
-      describe "#order" do
-        let(:unit) { build_inventory_unit }
-        context "there is an inventory unit" do
-          before { subject.add unit }
-
-          it "returns an order" do
-            expect(subject.order).to be_a_kind_of Spree::Order
-            expect(subject.order).to eq order
-          end
-        end
-
-        context "there is no inventory unit" do
-          it "returns nil" do
-            expect(subject.order).to eq nil
-          end
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/stock/quantifier_spec.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.shared_examples_for 'unlimited supply' do
-  it 'can_supply? any amount' do
-    expect(subject.can_supply?(1)).to eq true
-    expect(subject.can_supply?(101)).to eq true
-    expect(subject.can_supply?(100_001)).to eq true
-  end
-end
-
-module Spree
-  module Stock
-    RSpec.describe Quantifier, type: :model do
-      let(:target_stock_location) { nil }
-      let!(:stock_location) { create :stock_location_with_items }
-      let!(:stock_item) { stock_location.stock_items.order(:id).first }
-
-      subject { described_class.new(stock_item.variant, target_stock_location) }
-
-      specify { expect(subject.stock_items).to eq([stock_item]) }
-
-      context 'with a single stock location/item' do
-        it 'total_on_hand should match stock_item' do
-          expect(subject.total_on_hand).to eq stock_item.count_on_hand
-        end
-
-        context 'when track_inventory_levels is false' do
-          before { stub_spree_preferences(track_inventory_levels: false) }
-
-          specify { expect(subject.total_on_hand).to eq(Float::INFINITY) }
-
-          it_should_behave_like 'unlimited supply'
-        end
-
-        context 'when variant inventory tracking is off' do
-          before { stock_item.variant.track_inventory = false }
-
-          specify { expect(subject.total_on_hand).to eq(Float::INFINITY) }
-
-          it_should_behave_like 'unlimited supply'
-        end
-
-        context 'when stock item allows backordering' do
-          specify { expect(subject.backorderable?).to be true }
-
-          it_should_behave_like 'unlimited supply'
-        end
-
-        context 'when stock item prevents backordering' do
-          before { stock_item.update(backorderable: false) }
-
-          specify { expect(subject.backorderable?).to be false }
-
-          it 'can_supply? only upto total_on_hand' do
-            expect(subject.can_supply?(1)).to be true
-            expect(subject.can_supply?(10)).to be true
-            expect(subject.can_supply?(11)).to be false
-          end
-        end
-      end
-
-      context 'with multiple stock locations/items' do
-        let!(:stock_location_2) { create :stock_location }
-        let!(:stock_location_3) { create :stock_location, active: false }
-
-        before do
-          stock_location_2.stock_items.where(variant_id: stock_item.variant).update_all(count_on_hand: 5, backorderable: false)
-          stock_location_3.stock_items.where(variant_id: stock_item.variant).update_all(count_on_hand: 5, backorderable: false)
-        end
-
-        it 'total_on_hand should total all active stock_items' do
-          expect(subject.total_on_hand).to eq(15)
-        end
-
-        context 'when any stock item allows backordering' do
-          specify { expect(subject.backorderable?).to be true }
-
-          it_should_behave_like 'unlimited supply'
-        end
-
-        context 'when all stock items prevent backordering' do
-          before { stock_item.update(backorderable: false) }
-
-          specify { expect(subject.backorderable?).to be false }
-
-          it 'can_supply? upto total_on_hand' do
-            expect(subject.can_supply?(1)).to be true
-            expect(subject.can_supply?(15)).to be true
-            expect(subject.can_supply?(16)).to be false
-          end
-        end
-      end
-
-      context 'with a specific stock location' do
-        let!(:stock_location_2)     { create :stock_location }
-        let!(:stock_location_3)     { create :stock_location, active: false }
-        let(:target_stock_location) { stock_location_3 }
-
-        before do
-          Spree::StockItem.update_all(count_on_hand: 0, backorderable: false)
-          stock_location_3.stock_items.where(variant_id: stock_item.variant).update_all(count_on_hand: 5, backorderable: false)
-        end
-
-        it 'can_supply? only upto total_on_hand' do
-          expect(subject.can_supply?(5)).to eq true
-          expect(subject.can_supply?(6)).to eq false
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/stock/shipping_rate_selector_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Stock::ShippingRateSelector do
-  describe '#sort' do
-    it 'sorts by increasing cost' do
-      cheapest_shipping_rate = Spree::ShippingRate.new(cost: 1.00)
-      middle_shipping_rate = Spree::ShippingRate.new(cost: 5.00)
-      expensive_shipping_rate = Spree::ShippingRate.new(cost: 42.00)
-      shipping_rates = [expensive_shipping_rate, middle_shipping_rate, cheapest_shipping_rate]
-
-      sorter = Spree::Stock::ShippingRateSelector.new(shipping_rates)
-
-      expect(sorter.find_default).to eq(cheapest_shipping_rate)
-    end
-  end
-end

data/spec/models/spree/stock/shipping_rate_sorter_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Stock::ShippingRateSorter do
-  describe '#sort' do
-    it 'sorts by increasing cost' do
-      cheapest_shipping_rate = Spree::ShippingRate.new(cost: 1.00)
-      middle_shipping_rate = Spree::ShippingRate.new(cost: 5.00)
-      expensive_shipping_rate = Spree::ShippingRate.new(cost: 42.00)
-      shipping_rates = [expensive_shipping_rate, middle_shipping_rate, cheapest_shipping_rate]
-
-      sorter = Spree::Stock::ShippingRateSorter.new(shipping_rates)
-
-      expect(sorter.sort).to eq([cheapest_shipping_rate, middle_shipping_rate, expensive_shipping_rate])
-    end
-  end
-end

data/spec/models/spree/stock/simple_coordinator_spec.rb

@@ -1,264 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    RSpec.describe SimpleCoordinator, type: :model do
-      let(:order) { create(:order_with_line_items, line_items_count: 2) }
-
-      subject { SimpleCoordinator.new(order) }
-
-      describe "#shipments" do
-        it 'uses the pluggable estimator class' do
-          expect(Spree::Config.stock).to receive(:estimator_class).and_call_original
-          subject.shipments
-        end
-
-        it 'uses the configured stock location filter' do
-          expect(Spree::Config.stock).to receive(:location_filter_class).and_call_original
-          subject.shipments
-        end
-
-        it 'uses the configured stock location sorter' do
-          expect(Spree::Config.stock).to receive(:location_sorter_class).and_call_original
-          subject.shipments
-        end
-
-        it 'uses the pluggable allocator class' do
-          expect(Spree::Config.stock).to receive(:allocator_class).and_call_original
-          subject.shipments
-        end
-
-        it 'builds shipments' do
-          expect(subject.shipments.size).to eq(1)
-        end
-
-        it "builds a shipment for all active stock locations" do
-          subject.shipments.count == StockLocation.count
-        end
-
-        context "missing stock items in active stock location" do
-          let!(:another_location) { create(:stock_location, propagate_all_variants: false) }
-
-          it "builds shipments only for valid active stock locations" do
-            expect(subject.shipments.count).to eq(StockLocation.count - 1)
-          end
-        end
-
-        it "does not unintentionally add shipments to the order" do
-          subject.shipments
-          expect {
-            order.recalculate
-          }.not_to change {
-            order.shipments.count
-          }
-        end
-      end
-
-      describe "#allocate_inventory" do
-        it 'is deprecated' do
-          expect(Spree::Deprecation).to receive(:warn)
-          subject.send :allocate_inventory, subject.instance_variable_get(:@availability).on_hand_by_stock_location_id
-        end
-      end
-
-      # regression spec
-      context "when there is one unit that has stock in a stock location that a non-tracked unit has no stock item in" do
-        let!(:stock_location_1) { create(:stock_location, propagate_all_variants: false, active: true) }
-        let!(:stock_location_2) { create(:stock_location, propagate_all_variants: false, active: true) }
-
-        let!(:variant_1) do
-          create(:variant, track_inventory: true).tap do |variant|
-            variant.stock_items.destroy_all
-            stock_item = variant.stock_items.create!(stock_location: stock_location_1)
-            stock_item.set_count_on_hand(10)
-          end
-        end
-        let!(:variant_2) do
-          create(:variant, track_inventory: false).tap do |variant|
-            variant.stock_items.destroy_all
-            stock_item = variant.stock_items.create!(stock_location: stock_location_2)
-            stock_item.set_count_on_hand(0)
-          end
-        end
-
-        let!(:order) { create(:order, line_items: [create(:line_item, variant: variant_1), create(:line_item, variant: variant_2)]) }
-
-        it "splits the inventory units to stock locations that they have stock items for" do
-          shipments = subject.shipments
-
-          expect(shipments.size).to eq 2
-
-          location_1_shipment = shipments.detect { |shipment| shipment.stock_location == stock_location_1 }
-          location_2_shipment = shipments.detect { |shipment| shipment.stock_location == stock_location_2 }
-
-          expect(location_1_shipment).to be_present
-          expect(location_2_shipment).to be_present
-
-          expect(location_1_shipment.inventory_units.map(&:variant)).to eq [variant_1]
-          expect(location_2_shipment.inventory_units.map(&:variant)).to eq [variant_2]
-        end
-      end
-
-      context "with no backordering" do
-        let!(:stock_location_1) { create(:stock_location, propagate_all_variants: false, active: true) }
-
-        let!(:variant) { create(:variant, track_inventory: true) }
-
-        before do
-          stock_item_one = variant.stock_items.create!(stock_location: stock_location_1, backorderable: false)
-          stock_item_one.set_count_on_hand(location_1_inventory)
-        end
-
-        let!(:order) { create(:order) }
-        let!(:line_item) { create(:line_item, order: order, variant: variant, quantity: 5) }
-        before { order.reload }
-        let(:shipments) { subject.shipments }
-
-        shared_examples "a fulfillable package" do
-          it "packages correctly" do
-            expect(shipments).not_to be_empty
-            inventory_units = shipments.flat_map { |shipment| shipment.inventory_units }
-            expect(inventory_units.size).to eq(5)
-            expect(inventory_units.uniq.size).to eq(5)
-          end
-        end
-
-        shared_examples "an unfulfillable package" do
-          it "raises exception" do
-            expect{ shipments }.to raise_error(Spree::Order::InsufficientStock)
-          end
-        end
-
-        context 'with no stock locations' do
-          let(:location_1_inventory) { 0 }
-          before { variant.stock_items.each(&:really_destroy!) }
-          it_behaves_like "an unfulfillable package"
-        end
-
-        context 'with a single stock location' do
-          context "with no inventory" do
-            let(:location_1_inventory) { 0 }
-            it_behaves_like "an unfulfillable package"
-          end
-
-          context "with insufficient inventory" do
-            let(:location_1_inventory) { 1 }
-            it_behaves_like "an unfulfillable package"
-          end
-
-          context "with sufficient inventory" do
-            let(:location_1_inventory) { 5 }
-            it_behaves_like "a fulfillable package"
-          end
-        end
-
-        context 'with two stock locations' do
-          let!(:stock_location_2) { create(:stock_location, propagate_all_variants: false, active: true) }
-          before do
-            stock_item_two = variant.stock_items.create!(stock_location: stock_location_2, backorderable: false)
-            stock_item_two.set_count_on_hand(location_2_inventory)
-          end
-
-          context "with no inventory" do
-            let(:location_1_inventory) { 0 }
-            let(:location_2_inventory) { 0 }
-            it_behaves_like "an unfulfillable package"
-          end
-
-          context "with some but insufficient inventory in each location" do
-            let(:location_1_inventory) { 1 }
-            let(:location_2_inventory) { 1 }
-            it_behaves_like "an unfulfillable package"
-          end
-
-          context "has sufficient inventory in the first location" do
-            let(:location_1_inventory) { 5 }
-            let(:location_2_inventory) { 0 }
-            it_behaves_like "a fulfillable package"
-          end
-
-          context "has sufficient inventory in the second location" do
-            let(:location_1_inventory) { 0 }
-            let(:location_2_inventory) { 5 }
-            it_behaves_like "a fulfillable package"
-          end
-
-          context "with sufficient inventory only across both locations" do
-            let(:location_1_inventory) { 2 }
-            let(:location_2_inventory) { 3 }
-            it_behaves_like "a fulfillable package"
-          end
-
-          context "has sufficient inventory in the second location and some in the first" do
-            let(:location_1_inventory) { 2 }
-            let(:location_2_inventory) { 5 }
-            it_behaves_like "a fulfillable package"
-          end
-
-          context "has sufficient inventory in the first location and some in the second" do
-            let(:location_1_inventory) { 5 }
-            let(:location_2_inventory) { 2 }
-            it_behaves_like "a fulfillable package"
-          end
-
-          context "with sufficient inventory in both locations" do
-            let(:location_1_inventory) { 5 }
-            let(:location_2_inventory) { 5 }
-            it_behaves_like "a fulfillable package"
-          end
-        end
-
-        context 'with three stock locations' do
-          let!(:stock_location_2) { create(:stock_location, propagate_all_variants: false, active: true) }
-          let!(:stock_location_3) { create(:stock_location, propagate_all_variants: false, active: true) }
-          before do
-            stock_item_two = variant.stock_items.create!(stock_location: stock_location_2, backorderable: false)
-            stock_item_two.set_count_on_hand(location_2_inventory)
-
-            stock_item_three = variant.stock_items.create!(stock_location: stock_location_3, backorderable: false)
-            stock_item_three.set_count_on_hand(location_3_inventory)
-          end
-
-          # Regression test for https://github.com/solidusio/solidus/issues/2122
-          context "with sufficient inventory in first two locations" do
-            let(:location_1_inventory) { 3 }
-            let(:location_2_inventory) { 3 }
-            let(:location_3_inventory) { 3 }
-
-            it_behaves_like "a fulfillable package"
-
-            it "creates only two packages" do
-              expect(shipments.count).to eq(2)
-            end
-          end
-
-          context "with sufficient inventory only across all three locations" do
-            let(:location_1_inventory) { 2 }
-            let(:location_2_inventory) { 2 }
-            let(:location_3_inventory) { 2 }
-
-            it_behaves_like "a fulfillable package"
-
-            it "creates three packages" do
-              expect(shipments.count).to eq(3)
-            end
-          end
-
-          context "with sufficient inventory only across all three locations" do
-            let(:location_1_inventory) { 2 }
-            let(:location_2_inventory) { 2 }
-            let(:location_3_inventory) { 2 }
-
-            it_behaves_like "a fulfillable package"
-
-            it "creates three packages" do
-              expect(shipments.count).to eq(3)
-            end
-          end
-        end
-      end
-    end
-  end
-end