solidus_core 2.10.0 → 2.11.0

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

data/spec/models/spree/stock/splitter/backordered_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    module Splitter
-      RSpec.describe Backordered, type: :model do
-        let(:variant) { build(:variant) }
-
-        let(:stock_location) { mock_model(Spree::StockLocation) }
-
-        subject { Backordered.new(stock_location) }
-
-        it 'splits packages by status' do
-          package = Package.new(stock_location)
-          4.times { package.add build(:inventory_unit, variant: variant) }
-          5.times { package.add build(:inventory_unit, variant: variant), :backordered }
-
-          packages = subject.split([package])
-          expect(packages.count).to eq 2
-          expect(packages.first.quantity).to eq 4
-          expect(packages.first.on_hand.count).to eq 4
-          expect(packages.first.backordered.count).to eq 0
-
-          expect(packages[1].contents.count).to eq 5
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/stock/splitter/base_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    module Splitter
-      RSpec.describe Base, type: :model do
-        let(:stock_location) { mock_model(Spree::StockLocation) }
-
-        it 'continues to splitter chain' do
-          splitter_one = Base.new(stock_location)
-          splitter_two = Base.new(stock_location, splitter_one)
-          packages = []
-
-          expect(splitter_one).to receive(:split).with(packages)
-          splitter_two.split(packages)
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/stock/splitter/shipping_category_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    RSpec.describe Splitter::ShippingCategory, type: :model do
-      let(:order) { create(:order_with_line_items, line_items_count: 1) }
-      let(:line_item) { order.line_items.first }
-      let(:variant1) { build(:variant) }
-      let(:variant2) { build(:variant) }
-      let(:shipping_category_1) { create(:shipping_category, name: 'A') }
-      let(:shipping_category_2) { create(:shipping_category, name: 'B') }
-
-      def inventory_unit1
-        build(:inventory_unit, variant: variant1, order: order, line_item: line_item).tap do |inventory_unit|
-          inventory_unit.variant.product.shipping_category = shipping_category_1
-        end
-      end
-
-      def inventory_unit2
-        build(:inventory_unit, variant: variant2, order: order, line_item: line_item).tap do |inventory_unit|
-          inventory_unit.variant.product.shipping_category = shipping_category_2
-        end
-      end
-
-      let(:stock_location) { mock_model(Spree::StockLocation) }
-
-      subject { described_class.new(stock_location) }
-
-      it 'splits each package by shipping category' do
-        package_one = Package.new(stock_location)
-        4.times { package_one.add inventory_unit1 }
-        8.times { package_one.add inventory_unit2 }
-
-        package_two = Package.new(stock_location)
-        6.times { package_two.add inventory_unit1 }
-        9.times { package_two.add inventory_unit2, :backordered }
-
-        packages = subject.split([package_one, package_two])
-        expect(packages[0].quantity).to eq 4
-        expect(packages[1].quantity).to eq 8
-        expect(packages[2].quantity).to eq 6
-        expect(packages[3].quantity).to eq 9
-      end
-    end
-  end
-end

data/spec/models/spree/stock/splitter/weight_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    module Splitter
-      RSpec.describe Weight, type: :model do
-        let(:stock_location) { mock_model(Spree::StockLocation) }
-        let(:variant) { build(:base_variant, weight: 100) }
-
-        subject { Weight.new(stock_location) }
-
-        it 'splits and keeps splitting until all packages are underweight' do
-          package = Package.new(stock_location)
-          4.times { package.add build(:inventory_unit, variant: variant) }
-          packages = subject.split([package])
-          expect(packages.size).to eq 4
-        end
-
-        it 'handles packages that can not be reduced' do
-          package = Package.new(stock_location)
-          allow(variant).to receive_messages(weight: 200)
-          2.times { package.add build(:inventory_unit, variant: variant) }
-          packages = subject.split([package])
-          expect(packages.size).to eq 2
-        end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree::Stock
-  RSpec.describe SplitterChain, type: :model do
-    let(:stock_location) { mock_model(Spree::StockLocation) }
-    let(:splitter1) { Class.new(Splitter::Base) }
-    let(:splitter2) { Class.new(Splitter::Base) }
-
-    let(:package) { double(:package) }
-    let(:packages) { [package] }
-
-    subject { described_class.new(stock_location, splitters) }
-
-    context 'with no splitters' do
-      let(:splitters) { [] }
-
-      it "returns the packages unchanged" do
-        expect(subject.split(packages)).to eq packages
-      end
-    end
-
-    context 'with one splitter' do
-      let(:splitters) { [splitter1] }
-
-      it 'returns the result form the splitter' do
-        expected = double(:expected_packages)
-        expect_any_instance_of(splitter1).to receive(:split).with(packages).and_return(expected)
-
-        expect(subject.split(packages)).to be expected
-      end
-
-      it 'builds the splitters correctly' do
-        expect(splitter1).to receive(:new).with(stock_location, nil).and_call_original
-
-        subject.split(packages)
-      end
-    end
-
-    context 'with multiple splitters' do
-      let(:splitters) { [splitter1, splitter2] }
-
-      it 'builds the splitters in order' do
-        expect(splitter1).to receive(:new).with(stock_location, splitter2).and_call_original
-        expect(splitter2).to receive(:new).with(stock_location, nil).and_call_original
-
-        subject.split(packages)
-      end
-
-      it 'calls the splitters in order' do
-        expect_any_instance_of(splitter1).to receive(:split).with(packages).and_call_original
-        expect_any_instance_of(splitter2).to receive(:split).with(packages).and_call_original
-
-        subject.split(packages)
-      end
-
-      it 'returns the final result' do
-        expected = double(:expected_packages)
-        expect_any_instance_of(splitter2).to receive(:split).with(packages).and_return(expected)
-
-        expect(subject.split(packages)).to be expected
-      end
-    end
-  end
-end