spree_core 3.0.5 → 3.0.6

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

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    describe Prioritizer, :type => :model do
+      let(:order) { mock_model(Order) }
+      let(:stock_location) { build(:stock_location) }
+      let(:variant) { build(:variant) }
+
+      def inventory_units
+        @inventory_units ||= []
+      end
+
+      def build_inventory_unit
+        mock_model(InventoryUnit, variant: variant).tap do |unit|
+          inventory_units << unit
+        end
+      end
+
+      def pack
+        package = Package.new(order)
+        yield(package) if block_given?
+        package
+      end
+
+      it 'keeps a single package' do
+        package1 = pack do |package|
+          package.add build_inventory_unit
+          package.add build_inventory_unit
+        end
+
+        packages = [package1]
+        prioritizer = Prioritizer.new(inventory_units, packages)
+        packages = prioritizer.prioritized_packages
+        expect(packages.size).to eq 1
+      end
+
+      it 'removes duplicate packages' do
+        package1 = pack do |package|
+          package.add build_inventory_unit
+          package.add build_inventory_unit
+        end
+
+        package2 = pack do |package|
+          package.add inventory_units.first
+          package.add inventory_units.last
+        end
+
+        packages = [package1, package2]
+        prioritizer = Prioritizer.new(inventory_units, packages)
+        packages = prioritizer.prioritized_packages
+        expect(packages.size).to eq 1
+      end
+
+      it 'split over 2 packages' do
+        package1 = pack do |package|
+          package.add build_inventory_unit
+        end
+        package2 = pack do |package|
+          package.add build_inventory_unit
+        end
+
+        packages = [package1, package2]
+        prioritizer = Prioritizer.new(inventory_units, packages)
+        packages = prioritizer.prioritized_packages
+        expect(packages.size).to eq 2
+      end
+
+      it '1st has some, 2nd has remaining' do
+        5.times { build_inventory_unit }
+
+        package1 = pack do |package|
+          2.times { |i| package.add inventory_units[i] }
+        end
+        package2 = pack do |package|
+          5.times { |i| package.add inventory_units[i] }
+        end
+
+        packages = [package1, package2]
+        prioritizer = Prioritizer.new(inventory_units, packages)
+        packages = prioritizer.prioritized_packages
+        expect(packages.count).to eq 2
+        expect(packages[0].quantity).to eq 2
+        expect(packages[1].quantity).to eq 3
+      end
+
+      it '1st has backorder, 2nd has some' do
+        5.times { build_inventory_unit }
+
+        package1 = pack do |package|
+          5.times { |i| package.add inventory_units[i], :backordered }
+        end
+        package2 = pack do |package|
+          2.times { |i| package.add inventory_units[i] }
+        end
+
+        packages = [package1, package2]
+        prioritizer = Prioritizer.new(inventory_units, packages)
+        packages = prioritizer.prioritized_packages
+
+        expect(packages[0].quantity(:backordered)).to eq 3
+        expect(packages[1].quantity(:on_hand)).to eq 2
+      end
+
+      it '1st has backorder, 2nd has all' do
+        5.times { build_inventory_unit }
+
+        package1 = pack do |package|
+          3.times { |i| package.add inventory_units[i], :backordered }
+        end
+        package2 = pack do |package|
+          5.times { |i| package.add inventory_units[i] }
+        end
+
+        packages = [package1, package2]
+        prioritizer = Prioritizer.new(inventory_units, packages)
+        packages = prioritizer.prioritized_packages
+        expect(packages[0]).to eq package2
+        expect(packages[1]).to be_nil
+        expect(packages[0].quantity(:backordered)).to eq 0
+        expect(packages[0].quantity(:on_hand)).to eq 5
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+shared_examples_for 'unlimited supply' do
+  it 'can_supply? any amount' do
+    expect(subject.can_supply?(1)).to be true
+    expect(subject.can_supply?(101)).to be true
+    expect(subject.can_supply?(100_001)).to be true
+  end
+end
+
+module Spree
+  module Stock
+    describe Quantifier, type: :model do
+      before(:all) { Spree::StockLocation.destroy_all } # FIXME leaky database
+
+      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) }
+
+      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 { configure_spree_preferences { |config| config.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_attributes(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_attributes(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
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    module Splitter
+      describe Backordered, :type => :model do
+        let(:variant) { build(:variant) }
+
+        let(:packer) { build(:stock_packer) }
+
+        subject { Backordered.new(packer) }
+
+        it 'splits packages by status' do
+          package = Package.new(packer.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

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

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

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    module Splitter
+      describe ShippingCategory, :type => :model do
+
+        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
+          InventoryUnit.new(variant: variant1).tap do |inventory_unit|
+            inventory_unit.variant.product.shipping_category = shipping_category_1
+          end
+        end
+
+        def inventory_unit2
+          InventoryUnit.new(variant: variant2).tap do |inventory_unit|
+            inventory_unit.variant.product.shipping_category = shipping_category_2
+          end
+        end
+
+        let(:packer) { build(:stock_packer) }
+
+        subject { ShippingCategory.new(packer) }
+
+        it 'splits each package by shipping category' do
+          package1 = Package.new(packer.stock_location)
+          4.times { package1.add inventory_unit1 }
+          8.times { package1.add inventory_unit2 }
+
+          package2 = Package.new(packer.stock_location)
+          6.times { package2.add inventory_unit1 }
+          9.times { package2.add inventory_unit2, :backordered }
+
+          packages = subject.split([package1, package2])
+          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
+end

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    module Splitter
+      describe Weight, type: :model do
+        let(:packer) { build(:stock_packer) }
+        let(:heavy_variant) { build(:base_variant, weight: 100) }
+        let(:variant) { build(:base_variant, weight: 49) }
+
+        subject { Weight.new(packer) }
+
+        it 'splits and keeps splitting until all packages are underweight' do
+          package = Package.new(packer.stock_location)
+          2.times { package.add build(:inventory_unit, variant: heavy_variant) }
+          4.times { package.add build(:inventory_unit, variant: variant) }
+          2.times { package.add build(:inventory_unit, variant: heavy_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)
+          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_item_spec.rb

@@ -0,0 +1,410 @@
+require 'spec_helper'
+
+describe Spree::StockItem, :type => :model do
+  let(:stock_location) { create(:stock_location_with_items) }
+
+  subject { stock_location.stock_items.order(:id).first }
+
+  it 'maintains the count on hand for a variant' do
+    expect(subject.count_on_hand).to eq 10
+  end
+
+  it "can return the stock item's variant's name" do
+    expect(subject.variant_name).to eq(subject.variant.name)
+  end
+
+  context "available to be included in shipment" do
+    context "has stock" do
+      it { expect(subject).to be_available }
+    end
+
+    context "backorderable" do
+      before { subject.backorderable = true }
+      it { expect(subject).to be_available }
+    end
+
+    context "no stock and not backorderable" do
+      before do
+        subject.backorderable = false
+        allow(subject).to receive_messages(count_on_hand: 0)
+      end
+
+      it { expect(subject).not_to be_available }
+    end
+  end
+
+  describe 'reduce_count_on_hand_to_zero' do
+    context 'when count_on_hand > 0' do
+      before(:each) do
+        subject.update_column('count_on_hand', 4)
+         subject.reduce_count_on_hand_to_zero
+       end
+
+       it { expect(subject.count_on_hand).to eq(0) }
+     end
+
+     context 'when count_on_hand > 0' do
+       before(:each) do
+         subject.update_column('count_on_hand', -4)
+         @count_on_hand = subject.count_on_hand
+         subject.reduce_count_on_hand_to_zero
+       end
+
+       it { expect(subject.count_on_hand).to eq(@count_on_hand) }
+     end
+  end
+
+  context "adjust count_on_hand" do
+    let!(:current_on_hand) { subject.count_on_hand }
+
+    it 'is updated pessimistically' do
+      copy = Spree::StockItem.find(subject.id)
+
+      subject.adjust_count_on_hand(5)
+      expect(subject.count_on_hand).to eq(current_on_hand + 5)
+
+      expect(copy.count_on_hand).to eq(current_on_hand)
+      copy.adjust_count_on_hand(5)
+      expect(copy.count_on_hand).to eq(current_on_hand + 10)
+    end
+
+    context "item out of stock (by two items)" do
+      let(:inventory_unit) { double('InventoryUnit') }
+      let(:inventory_unit_2) { double('InventoryUnit2') }
+
+      before do
+        allow(subject).to receive_messages(:backordered_inventory_units => [inventory_unit, inventory_unit_2])
+        subject.update_column(:count_on_hand, -2)
+      end
+
+      # Regression test for #3755
+      it "processes existing backorders, even with negative stock" do
+        expect(inventory_unit).to receive(:fill_backorder)
+        expect(inventory_unit_2).not_to receive(:fill_backorder)
+        subject.adjust_count_on_hand(1)
+        expect(subject.count_on_hand).to eq(-1)
+      end
+
+      # Test for #3755
+      it "does not process backorders when stock is adjusted negatively" do
+        expect(inventory_unit).not_to receive(:fill_backorder)
+        expect(inventory_unit_2).not_to receive(:fill_backorder)
+        subject.adjust_count_on_hand(-1)
+        expect(subject.count_on_hand).to eq(-3)
+      end
+
+      context "adds new items" do
+        before { allow(subject).to receive_messages(:backordered_inventory_units => [inventory_unit, inventory_unit_2]) }
+
+        it "fills existing backorders" do
+          expect(inventory_unit).to receive(:fill_backorder)
+          expect(inventory_unit_2).to receive(:fill_backorder)
+
+          subject.adjust_count_on_hand(3)
+          expect(subject.count_on_hand).to eq(1)
+        end
+      end
+    end
+  end
+
+  context "set count_on_hand" do
+    let!(:current_on_hand) { subject.count_on_hand }
+
+    it 'is updated pessimistically' do
+      copy = Spree::StockItem.find(subject.id)
+
+      subject.set_count_on_hand(5)
+      expect(subject.count_on_hand).to eq(5)
+
+      expect(copy.count_on_hand).to eq(current_on_hand)
+      copy.set_count_on_hand(10)
+      expect(copy.count_on_hand).to eq(current_on_hand)
+    end
+
+    context "item out of stock (by two items)" do
+      let(:inventory_unit) { double('InventoryUnit') }
+      let(:inventory_unit_2) { double('InventoryUnit2') }
+
+      before { subject.set_count_on_hand(-2) }
+
+      it "doesn't process backorders" do
+        expect(subject).not_to receive(:backordered_inventory_units)
+      end
+
+      context "adds new items" do
+        before { allow(subject).to receive_messages(:backordered_inventory_units => [inventory_unit, inventory_unit_2]) }
+
+        it "fills existing backorders" do
+          expect(inventory_unit).to receive(:fill_backorder)
+          expect(inventory_unit_2).to receive(:fill_backorder)
+
+          subject.set_count_on_hand(1)
+          expect(subject.count_on_hand).to eq(1)
+        end
+      end
+    end
+  end
+
+  context "with stock movements" do
+    before { Spree::StockMovement.create(stock_item: subject, quantity: 1) }
+
+    it "doesnt raise ReadOnlyRecord error" do
+      expect { subject.destroy }.not_to raise_error
+    end
+  end
+
+  context "destroyed" do
+    before { subject.destroy }
+
+    it "recreates stock item just fine" do
+      expect {
+        stock_location.stock_items.create!(variant: subject.variant)
+      }.not_to raise_error
+    end
+
+    it "doesnt allow recreating more than one stock item at once" do
+      stock_location.stock_items.create!(variant: subject.variant)
+
+      expect {
+        stock_location.stock_items.create!(variant: subject.variant)
+      }.to raise_error
+    end
+  end
+
+  describe "#after_save" do
+    before do
+      subject.variant.update_column(:updated_at, 1.day.ago)
+    end
+
+    context "binary_inventory_cache is set to false (default)" do
+      context "in_stock? changes" do
+        it "touches its variant" do
+          expect do
+            subject.adjust_count_on_hand(subject.count_on_hand * -1)
+          end.to change { subject.variant.reload.updated_at }
+        end
+      end
+
+      context "in_stock? does not change" do
+        it "touches its variant" do
+          expect do
+            subject.adjust_count_on_hand((subject.count_on_hand * -1) + 1)
+          end.to change { subject.variant.reload.updated_at }
+        end
+      end
+    end
+
+    context "binary_inventory_cache is set to true" do
+      before { Spree::Config.binary_inventory_cache = true }
+      context "in_stock? changes" do
+        it "touches its variant" do
+          expect do
+            subject.adjust_count_on_hand(subject.count_on_hand * -1)
+          end.to change { subject.variant.reload.updated_at }
+        end
+      end
+
+      context "in_stock? does not change" do
+        it "does not touch its variant" do
+          expect do
+            subject.adjust_count_on_hand((subject.count_on_hand * -1) + 1)
+          end.not_to change { subject.variant.reload.updated_at }
+        end
+      end
+
+      context "when a new stock location is added" do
+        it "touches its variant" do
+          expect do
+            create(:stock_location)
+          end.to change { subject.variant.reload.updated_at }
+        end
+      end
+    end
+  end
+
+  describe "#after_touch" do
+    it "touches its variant" do
+      expect do
+        subject.touch
+      end.to change { subject.variant.updated_at }
+    end
+  end
+
+  # Regression test for #4651
+  context "variant" do
+    it "can be found even if the variant is deleted" do
+      subject.variant.destroy
+      expect(subject.reload.variant).not_to be_nil
+    end
+  end
+
+  describe 'validations' do
+    describe 'count_on_hand' do
+      shared_examples_for 'valid count_on_hand' do
+        before(:each) do
+          subject.save
+        end
+
+        it 'has :no errors_on' do
+          expect(subject.errors_on(:count_on_hand).size).to eq(0)
+        end
+      end
+
+      shared_examples_for 'not valid count_on_hand' do
+        before(:each) do
+          subject.save
+        end
+
+        it 'has 1 error_on' do
+          expect(subject.error_on(:count_on_hand).size).to eq(1)
+        end
+        it { expect(subject.errors[:count_on_hand]).to include 'must be greater than or equal to 0' }
+      end
+
+      context 'when count_on_hand not changed' do
+        context 'when not backorderable' do
+          before(:each) do
+            subject.backorderable = false
+          end
+          it_should_behave_like 'valid count_on_hand'
+        end
+
+        context 'when backorderable' do
+          before(:each) do
+            subject.backorderable = true
+          end
+          it_should_behave_like 'valid count_on_hand'
+        end
+      end
+
+      context 'when count_on_hand changed' do
+        context 'when backorderable' do
+          before(:each) do
+            subject.backorderable = true
+          end
+          context 'when both count_on_hand and count_on_hand_was are positive' do
+            context 'when count_on_hand is greater than count_on_hand_was' do
+              before(:each) do
+                subject.update_column(:count_on_hand, 3)
+                subject.send(:count_on_hand=, subject.count_on_hand + 3)
+              end
+              it_should_behave_like 'valid count_on_hand'
+            end
+
+            context 'when count_on_hand is smaller than count_on_hand_was' do
+              before(:each) do
+                subject.update_column(:count_on_hand, 3)
+                subject.send(:count_on_hand=, subject.count_on_hand - 2)
+              end
+
+              it_should_behave_like 'valid count_on_hand'
+            end
+          end
+
+          context 'when both count_on_hand and count_on_hand_was are negative' do
+            context 'when count_on_hand is greater than count_on_hand_was' do
+              before(:each) do
+                subject.update_column(:count_on_hand, -3)
+                subject.send(:count_on_hand=, subject.count_on_hand + 2)
+              end
+              it_should_behave_like 'valid count_on_hand'
+            end
+
+            context 'when count_on_hand is smaller than count_on_hand_was' do
+              before(:each) do
+                subject.update_column(:count_on_hand, 3)
+                subject.send(:count_on_hand=, subject.count_on_hand - 3)
+              end
+
+              it_should_behave_like 'valid count_on_hand'
+            end
+          end
+
+          context 'when both count_on_hand is positive and count_on_hand_was is negative' do
+            context 'when count_on_hand is greater than count_on_hand_was' do
+              before(:each) do
+                subject.update_column(:count_on_hand, -3)
+                subject.send(:count_on_hand=, subject.count_on_hand + 6)
+              end
+              it_should_behave_like 'valid count_on_hand'
+            end
+          end
+
+          context 'when both count_on_hand is negative and count_on_hand_was is positive' do
+            context 'when count_on_hand is greater than count_on_hand_was' do
+              before(:each) do
+                subject.update_column(:count_on_hand, 3)
+                subject.send(:count_on_hand=, subject.count_on_hand - 6)
+              end
+              it_should_behave_like 'valid count_on_hand'
+            end
+          end
+        end
+
+        context 'when not backorderable' do
+          before(:each) do
+            subject.backorderable = false
+          end
+
+          context 'when both count_on_hand and count_on_hand_was are positive' do
+            context 'when count_on_hand is greater than count_on_hand_was' do
+              before(:each) do
+                subject.update_column(:count_on_hand, 3)
+                subject.send(:count_on_hand=, subject.count_on_hand + 3)
+              end
+              it_should_behave_like 'valid count_on_hand'
+            end
+
+            context 'when count_on_hand is smaller than count_on_hand_was' do
+              before(:each) do
+                subject.update_column(:count_on_hand, 3)
+                subject.send(:count_on_hand=, subject.count_on_hand - 2)
+              end
+
+              it_should_behave_like 'valid count_on_hand'
+            end
+          end
+
+          context 'when both count_on_hand and count_on_hand_was are negative' do
+            context 'when count_on_hand is greater than count_on_hand_was' do
+              before(:each) do
+                subject.update_column(:count_on_hand, -3)
+                subject.send(:count_on_hand=, subject.count_on_hand + 2)
+              end
+              it_should_behave_like 'valid count_on_hand'
+            end
+
+            context 'when count_on_hand is smaller than count_on_hand_was' do
+              before(:each) do
+                subject.update_column(:count_on_hand, -3)
+                subject.send(:count_on_hand=, subject.count_on_hand - 3)
+              end
+
+              it_should_behave_like 'not valid count_on_hand'
+            end
+          end
+
+          context 'when both count_on_hand is positive and count_on_hand_was is negative' do
+            context 'when count_on_hand is greater than count_on_hand_was' do
+              before(:each) do
+                subject.update_column(:count_on_hand, -3)
+                subject.send(:count_on_hand=, subject.count_on_hand + 6)
+              end
+              it_should_behave_like 'valid count_on_hand'
+            end
+          end
+
+          context 'when both count_on_hand is negative and count_on_hand_was is positive' do
+            context 'when count_on_hand is greater than count_on_hand_was' do
+              before(:each) do
+                subject.update_column(:count_on_hand, 3)
+                subject.send(:count_on_hand=, subject.count_on_hand - 6)
+              end
+              it_should_behave_like 'not valid count_on_hand'
+            end
+          end
+        end
+      end
+    end
+  end
+end