solidus_core 2.3.1 → 2.4.0.beta1

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

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
   module Stock
-    describe AvailabilityValidator do
+    RSpec.describe AvailabilityValidator do
       let(:validator) { Spree::Stock::AvailabilityValidator.new }
 
       subject { validator.validate(line_item) }

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

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
   module Stock
-    describe Differentiator, type: :model do
+    RSpec.describe Differentiator, type: :model do
       let(:variant1) { mock_model(Variant) }
       let(:variant2) { mock_model(Variant) }
 

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

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
   module Stock
-    describe Estimator, type: :model do
+    RSpec.describe Estimator, type: :model do
       let(:shipping_rate) { 4.00 }
       let!(:shipping_method) { create(:shipping_method, cost: shipping_rate, currency: currency) }
       let(:package) do

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

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
   module Stock
-    describe InventoryUnitBuilder, type: :model do
+    RSpec.describe InventoryUnitBuilder, type: :model do
       let(:line_item_1) { build(:line_item) }
       let(:line_item_2) { build(:line_item, quantity: 2) }
       let(:order) { build(:order, line_items: [line_item_1, line_item_2]) }

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

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
   module Stock
-    describe Package, type: :model do
+    RSpec.describe Package, type: :model do
       let(:variant) { build(:variant, weight: 25.0) }
       let(:stock_location) { build(:stock_location) }
       let(:order) { build(:order) }

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

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'rails_helper'
 
-shared_examples_for 'unlimited supply' do
+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
@@ -10,7 +10,7 @@ end
 
 module Spree
   module Stock
-    describe Quantifier, type: :model do
+    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 }

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

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Spree::Stock::ShippingRateSelector do
+RSpec.describe Spree::Stock::ShippingRateSelector do
   describe '#sort' do
     it 'sorts by increasing cost' do
       cheapest_shipping_rate = Spree::ShippingRate.new(cost: 1.00)

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

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Spree::Stock::ShippingRateSorter do
+RSpec.describe Spree::Stock::ShippingRateSorter do
   describe '#sort' do
     it 'sorts by increasing cost' do
       cheapest_shipping_rate = Spree::ShippingRate.new(cost: 1.00)

data/spec/models/spree/stock/{coordinator_spec.rb → simple_coordinator_spec.rb}

@@ -1,22 +1,13 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
   module Stock
-    describe Coordinator, type: :model do
+    RSpec.describe SimpleCoordinator, type: :model do
       let(:order) { create(:order_with_line_items, line_items_count: 2) }
 
-      subject { Coordinator.new(order) }
+      subject { SimpleCoordinator.new(order) }
 
       describe "#shipments" do
-        it "builds, prioritizes and estimates" do
-          expect(subject).to receive(:build_location_configured_packages).ordered.and_call_original
-          expect(subject).to receive(:build_packages).ordered.and_call_original
-          expect(subject).to receive(:prioritize_packages).ordered.and_call_original
-          expect(subject).to receive(:estimate_packages).ordered.and_call_original
-          expect(subject).to receive(:validate_packages).ordered.and_call_original
-          subject.shipments
-        end
-
         it 'uses the pluggable estimator class' do
           expect(Spree::Config.stock).to receive(:estimator_class).and_call_original
           subject.shipments
@@ -41,7 +32,7 @@ module Spree
         it "does not unintentionally add shipments to the order" do
           subject.shipments
           expect {
-            order.update!
+            order.recalculate
           }.not_to change {
             order.shipments.count
           }
@@ -173,7 +164,6 @@ module Spree
           context "with sufficient inventory only across both locations" do
             let(:location_1_inventory) { 2 }
             let(:location_2_inventory) { 3 }
-            before { pending "This is broken. The coordinator packages this incorrectly" }
             it_behaves_like "a fulfillable package"
           end
 
@@ -214,28 +204,57 @@ module Spree
             context "and insufficient inventory" do
               let(:location_1_inventory) { 0 }
               let(:location_2_inventory) { 3 }
-              before { pending "This is broken. The coordinator packages this incorrectly" }
               it_behaves_like "an unfulfillable package"
             end
           end
         end
-      end
-
-      context "build location configured packages" do
-        context "there are configured stock locations" do
-          let!(:stock_location) { order.variants.first.stock_locations.first }
-          let!(:stock_location_2) { create(:stock_location) }
 
+        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
-            line_item_1 = order.line_items.first
-            line_item_2 = order.line_items.last
-            order.order_stock_locations.create(stock_location_id: stock_location.id, quantity: line_item_1.quantity, variant_id: line_item_1.variant_id)
-            order.order_stock_locations.create(stock_location_id: stock_location_2.id, quantity: line_item_2.quantity, variant_id: line_item_2.variant_id)
+            stock_item2 = variant.stock_items.create!(stock_location: stock_location_2, backorderable: false)
+            stock_item2.set_count_on_hand(location_2_inventory)
+
+            stock_item3 = variant.stock_items.create!(stock_location: stock_location_3, backorderable: false)
+            stock_item3.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
 
-          it "builds a shipment for each associated stock location" do
-            shipments = subject.shipments
-            expect(shipments.map(&:stock_location)).to match_array([stock_location, stock_location_2])
+          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

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

@@ -1,17 +1,17 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
   module Stock
     module Splitter
-      describe Backordered, type: :model do
+      RSpec.describe Backordered, type: :model do
         let(:variant) { build(:variant) }
 
-        let(:packer) { build(:stock_packer) }
+        let(:stock_location) { mock_model(Spree::StockLocation) }
 
-        subject { Backordered.new(packer) }
+        subject { Backordered.new(stock_location) }
 
         it 'splits packages by status' do
-          package = Package.new(packer.stock_location)
+          package = Package.new(stock_location)
           4.times { package.add build(:inventory_unit, variant: variant) }
           5.times { package.add build(:inventory_unit, variant: variant), :backordered }
 

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

@@ -1,14 +1,14 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
   module Stock
     module Splitter
-      describe Base, type: :model do
-        let(:packer) { build(:stock_packer) }
+      RSpec.describe Base, type: :model do
+        let(:stock_location) { mock_model(Spree::StockLocation) }
 
         it 'continues to splitter chain' do
-          splitter1 = Base.new(packer)
-          splitter2 = Base.new(packer, splitter1)
+          splitter1 = Base.new(stock_location)
+          splitter2 = Base.new(stock_location, splitter1)
           packages = []
 
           expect(splitter1).to receive(:split).with(packages)

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

@@ -1,8 +1,8 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
   module Stock
-    describe Splitter::ShippingCategory, type: :model do
+    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) }
@@ -22,16 +22,16 @@ module Spree
         end
       end
 
-      let(:packer) { build(:stock_packer) }
+      let(:stock_location) { mock_model(Spree::StockLocation) }
 
-      subject { described_class.new(packer) }
+      subject { described_class.new(stock_location) }
 
       it 'splits each package by shipping category' do
-        package1 = Package.new(packer.stock_location)
+        package1 = Package.new(stock_location)
         4.times { package1.add inventory_unit1 }
         8.times { package1.add inventory_unit2 }
 
-        package2 = Package.new(packer.stock_location)
+        package2 = Package.new(stock_location)
         6.times { package2.add inventory_unit1 }
         9.times { package2.add inventory_unit2, :backordered }
 

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

@@ -1,23 +1,23 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
   module Stock
     module Splitter
-      describe Weight, type: :model do
-        let(:packer) { build(:stock_packer) }
+      RSpec.describe Weight, type: :model do
+        let(:stock_location) { mock_model(Spree::StockLocation) }
         let(:variant) { build(:base_variant, weight: 100) }
 
-        subject { Weight.new(packer) }
+        subject { Weight.new(stock_location) }
 
         it 'splits and keeps splitting until all packages are underweight' do
-          package = Package.new(packer.stock_location)
+          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(packer.stock_location)
+          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])

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

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

data/spec/models/spree/stock_item_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Spree::StockItem, type: :model do
+RSpec.describe Spree::StockItem, type: :model do
   let(:stock_location) { create(:stock_location_with_items) }
 
   subject { stock_location.stock_items.order(:id).first }

data/spec/models/spree/stock_location_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require 'rails_helper'
 
 module Spree
-  describe StockLocation, type: :model do
+  RSpec.describe StockLocation, type: :model do
     subject { create(:stock_location_with_items, backorderable_default: true) }
     let(:stock_item) { subject.stock_items.order(:id).first }
     let(:variant) { stock_item.variant }

data/spec/models/spree/stock_movement_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
+require 'rails_helper'
 
-describe Spree::StockMovement, type: :model do
+RSpec.describe Spree::StockMovement, type: :model do
   let(:stock_location) { create(:stock_location_with_items) }
   let(:stock_item) { stock_location.stock_items.order(:id).first }
   subject { build(:stock_movement, stock_item: stock_item) }

data/spec/models/spree/stock_quantities_spec.rb

@@ -0,0 +1,247 @@
+require 'rails_helper'
+
+RSpec.describe Spree::StockQuantities, type: :model do
+  let(:variant1) { mock_model(Spree::Variant) }
+  let(:variant2) { mock_model(Spree::Variant) }
+
+  subject do
+    described_class.new(quantities)
+  end
+
+  describe "#each" do
+    def expect_each
+      expect { |b| subject.each(&b) }
+    end
+
+    context "with no items" do
+      let(:quantities) { {} }
+
+      it "doesn't yield" do
+        expect_each.not_to yield_control
+      end
+    end
+
+    context "with one item" do
+      let(:quantities) { { variant1 => 2 } }
+
+      it "yields values" do
+        expect_each.to yield_with_args([variant1, 2])
+      end
+    end
+
+    context "with two items" do
+      let(:quantities) { { variant1 => 2, variant2 => 3 } }
+
+      it "yields values" do
+        expect_each.to yield_successive_args([variant1, 2], [variant2, 3])
+      end
+    end
+  end
+
+  describe "#variants" do
+    context "with one item" do
+      let(:quantities) { { variant1 => 2 } }
+
+      it "returns variant" do
+        expect(subject.variants).to eq [variant1]
+      end
+    end
+
+    context "with two items" do
+      let(:quantities) { { variant1 => 2, variant2 => 3 } }
+
+      it "returns both variants" do
+        expect(subject.variants).to eq [variant1, variant2]
+      end
+    end
+  end
+
+  describe "#empty?" do
+    context "no variants" do
+      let(:quantities) { {} }
+      it { is_expected.to be_empty }
+    end
+
+    context "only quantity 0" do
+      let(:quantities) { { variant1 => 0 } }
+      it { is_expected.to be_empty }
+    end
+
+    context "positive quantity" do
+      let(:quantities) { { variant1 => 1 } }
+      it { is_expected.not_to be_empty }
+    end
+
+    context "one variant positive one zero" do
+      let(:quantities) { { variant1 => 1, variant2 => 0 } }
+      it { is_expected.not_to be_empty }
+    end
+
+    context "negative quantity" do
+      # empty? doesn't make a whole lot of sense in this case, but returning
+      # false is probably more accurate.
+      let(:quantities) { { variant1 => -1 } }
+      it { is_expected.not_to be_empty }
+    end
+  end
+
+  describe "==" do
+    subject do
+      described_class.new(quantity1) == described_class.new(quantity2)
+    end
+
+    context "when both empty" do
+      let(:quantity1) { {} }
+      let(:quantity2) { {} }
+      it { is_expected.to be true }
+    end
+
+    context "when both equal" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { { variant1 => 1 } }
+      it { is_expected.to be true }
+    end
+
+    context "with different order" do
+      let(:quantity1) { { variant1 => 1, variant2 => 2 } }
+      let(:quantity2) { { variant2 => 2, variant1 => 1 } }
+      it { is_expected.to be true }
+    end
+
+    context "with different variant" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { { variant2 => 1 } }
+      it { is_expected.to be false }
+    end
+
+    context "with different quantities" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { { variant1 => 2 } }
+      it { is_expected.to be false }
+    end
+
+    context "nil != 0" do
+      let(:quantity1) { { variant1 => 0 } }
+      let(:quantity2) { {} }
+      it { is_expected.to be false }
+    end
+  end
+
+  describe "+" do
+    subject do
+      described_class.new(quantity1) + described_class.new(quantity2)
+    end
+
+    context "same variant" do
+      let(:quantity1) { { variant1 => 20 } }
+      let(:quantity2) { { variant1 => 22 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 42 }) }
+    end
+
+    context "different variants" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { { variant2 => 2 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 1, variant2 => 2 }) }
+    end
+
+    context "0 quantities" do
+      let(:quantity1) { { variant1 => 0 } }
+      let(:quantity2) { { variant2 => 1 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 0, variant2 => 1 }) }
+    end
+
+    context "empty quantity" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { {} }
+
+      it { is_expected.to eq described_class.new({ variant1 => 1 }) }
+    end
+  end
+
+  describe "-" do
+    subject do
+      described_class.new(quantity1) - described_class.new(quantity2)
+    end
+
+    context "same variant" do
+      let(:quantity1) { { variant1 => 22 } }
+      let(:quantity2) { { variant1 => 20 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 2 }) }
+    end
+
+    context "different variants" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { { variant2 => 2 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 1, variant2 => -2 }) }
+    end
+
+    context "0 quantity" do
+      let(:quantity1) { { variant1 => 0 } }
+      let(:quantity2) { { variant1 => 1 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => -1 }) }
+    end
+
+    context "empty quantity RHS" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { {} }
+
+      it { is_expected.to eq described_class.new({ variant1 => 1 }) }
+    end
+
+    context "empty quantity LHS" do
+      let(:quantity1) { {} }
+      let(:quantity2) { { variant1 => 1 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => -1 }) }
+    end
+  end
+
+  # Common subset
+  describe "&" do
+    subject do
+      described_class.new(quantity1) & described_class.new(quantity2)
+    end
+
+    context "same variant" do
+      let(:quantity1) { { variant1 => 20 } }
+      let(:quantity2) { { variant1 => 22 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 20 }) }
+    end
+
+    context "multiple variants" do
+      let(:quantity1) { { variant1 => 10, variant2 => 20 } }
+      let(:quantity2) { { variant1 => 12, variant2 => 14 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 10, variant2 => 14 }) }
+    end
+
+    context "different variants" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { { variant2 => 2 } }
+
+      it { is_expected.to be_empty }
+      it { is_expected.to eq described_class.new({}) }
+    end
+
+    context "0 quantities" do
+      let(:quantity1) { { variant1 => 0 } }
+      let(:quantity2) { { variant1 => 1 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 0 }) }
+    end
+
+    context "empty quantity" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { {} }
+
+      it { is_expected.to eq described_class.new({}) }
+    end
+  end
+end