solidus_core 1.1.0 → 1.1.1

data/spec/models/spree/stock_item_spec.rb

@@ -0,0 +1,444 @@
+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 ActiveRecord::RecordInvalid
+    end
+  end
+
+  describe "#after_save" do
+    before do
+      subject.variant.update_column(:updated_at, 1.day.ago)
+    end
+
+    context "inventory_cache_threshold is not set (default)" do
+      context "in_stock? changes" do
+        it "touches its variant" do
+          expect do
+            subject.set_count_on_hand(0)
+          end.to change { subject.variant.updated_at }
+        end
+      end
+
+      context "in_stock? does not change" do
+        it "touches its variant" do
+          expect do
+            subject.set_count_on_hand(-1)
+          end.to change { subject.variant.updated_at }
+        end
+      end
+    end
+
+    context "inventory_cache_threshold is set" do
+      before do
+        Spree::Config.inventory_cache_threshold = inventory_cache_threshold
+      end
+
+      let(:inventory_cache_threshold) { 5 }
+
+      it "count on hand falls below threshold" do
+        expect do
+          subject.set_count_on_hand(3)
+        end.to change { subject.variant.updated_at }
+      end
+
+      it "count on hand rises above threshold" do
+        subject.set_count_on_hand(2)
+        expect do
+          subject.set_count_on_hand(7)
+        end.to change { subject.variant.updated_at }
+      end
+
+      it "count on hand stays below threshold" do
+        subject.set_count_on_hand(2)
+        expect do
+          subject.set_count_on_hand(3)
+        end.to change { subject.variant.updated_at }
+      end
+
+      it "count on hand stays above threshold" do
+        expect do
+          subject.set_count_on_hand(8)
+        end.not_to change { subject.variant.updated_at }
+      end
+    end
+
+    context "when deprecated binary_inventory_cache is used" do
+      before do
+        Spree::Config.binary_inventory_cache = binary_inventory_cache
+        allow(ActiveSupport::Deprecation).to receive(:warn)
+        subject.set_count_on_hand(9)
+      end
+
+      context "binary_inventory_cache is set to true" do
+        let(:binary_inventory_cache) { true }
+
+        it "logs a deprecation warning" do
+          expect(ActiveSupport::Deprecation).to have_received(:warn)
+        end
+      end
+
+      context "binary_inventory_cache is set to false" do
+        let(:binary_inventory_cache) { false }
+        it "inventory_cache_threshold remains nil" do
+          expect(Spree::Config.inventory_cache_threshold).to be_nil
+        end
+
+        it "does not log a deprecation warning" do
+          expect(ActiveSupport::Deprecation).not_to have_received(:warn)
+        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

data/spec/models/spree/stock_location_spec.rb

@@ -0,0 +1,279 @@
+require 'spec_helper'
+
+module Spree
+  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 }
+
+    it 'creates stock_items for all variants' do
+      expect(subject.stock_items.count).to eq Variant.count
+    end
+
+    context "handling stock items" do
+      let!(:variant) { create(:variant) }
+
+      context "given a variant" do
+        subject { StockLocation.create(name: "testing", propagate_all_variants: false) }
+
+        context "set up" do
+          it "creates stock item" do
+            expect(subject).to receive(:propagate_variant)
+            subject.set_up_stock_item(variant)
+          end
+
+          context "stock item exists" do
+            let!(:stock_item) { subject.propagate_variant(variant) }
+
+            it "returns existing stock item" do
+              expect(subject.set_up_stock_item(variant)).to eq(stock_item)
+            end
+          end
+        end
+
+        context "propagate variants" do
+          let(:stock_item) { subject.propagate_variant(variant) }
+
+          it "creates a new stock item" do
+            expect {
+              subject.propagate_variant(variant)
+            }.to change{ StockItem.count }.by(1)
+          end
+
+          context "passes backorderable default config" do
+            context "true" do
+              before { subject.backorderable_default = true }
+              it { expect(stock_item.backorderable).to be true }
+            end
+
+            context "false" do
+              before { subject.backorderable_default = false }
+              it { expect(stock_item.backorderable).to be false }
+            end
+          end
+        end
+
+        context "propagate all variants" do
+          subject { StockLocation.new(name: "testing") }
+
+          context "true" do
+            before { subject.propagate_all_variants = true }
+
+            specify do
+              expect(subject).to receive(:propagate_variant).at_least(:once)
+              subject.save!
+            end
+          end
+
+          context "false" do
+            before { subject.propagate_all_variants = false }
+
+            specify do
+              expect(subject).not_to receive(:propagate_variant)
+              subject.save!
+            end
+          end
+        end
+      end
+    end
+
+    it 'finds a stock_item for a variant' do
+      stock_item = subject.stock_item(variant)
+      expect(stock_item.count_on_hand).to eq 10
+    end
+
+    it 'finds a stock_item for a variant by id' do
+      stock_item = subject.stock_item(variant.id)
+      expect(stock_item.variant).to eq variant
+    end
+
+    it 'returns nil when stock_item is not found for variant' do
+      stock_item = subject.stock_item(100)
+      expect(stock_item).to be_nil
+    end
+
+    describe '#stock_item_or_create' do
+      before do
+        variant = create(:variant)
+        variant.stock_items.destroy_all
+        variant.save
+      end
+
+      it 'creates a stock_item if not found for a variant' do
+        stock_item = subject.stock_item_or_create(variant)
+        expect(stock_item.variant).to eq variant
+      end
+
+      it 'creates a stock_item if not found for a variant_id' do
+        stock_item = subject.stock_item_or_create(variant.id)
+        expect(stock_item.variant).to eq variant
+      end
+    end
+
+    it 'finds a count_on_hand for a variant' do
+       expect(subject.count_on_hand(variant)).to eq 10
+    end
+
+    it 'finds determines if you a variant is backorderable' do
+      expect(subject.backorderable?(variant)).to be true
+    end
+
+    it 'restocks a variant with a positive stock movement' do
+      originator = double
+      expect(subject).to receive(:move).with(variant, 5, originator)
+      subject.restock(variant, 5, originator)
+    end
+
+    it 'unstocks a variant with a negative stock movement' do
+      originator = double
+      expect(subject).to receive(:move).with(variant, -5, originator)
+      subject.unstock(variant, 5, originator)
+    end
+
+    it 'it creates a stock_movement' do
+      expect {
+        subject.move variant, 5
+      }.to change { subject.stock_movements.where(stock_item_id: stock_item).count }.by(1)
+    end
+
+    it 'can be deactivated' do
+      create(:stock_location, :active => true)
+      create(:stock_location, :active => false)
+      expect(Spree::StockLocation.active.count).to eq 1
+    end
+
+    it 'ensures only one stock location is default at a time' do
+      first = create(:stock_location, :active => true, :default => true)
+      second = create(:stock_location, :active => true, :default => true)
+
+      expect(first.reload.default).to eq false
+      expect(second.reload.default).to eq true
+
+      first.default = true
+      first.save!
+
+      expect(first.reload.default).to eq true
+      expect(second.reload.default).to eq false
+    end
+
+    context 'fill_status' do
+      it 'all on_hand with no backordered' do
+        on_hand, backordered = subject.fill_status(variant, 5)
+        expect(on_hand).to eq 5
+        expect(backordered).to eq 0
+      end
+
+      it 'some on_hand with some backordered' do
+        on_hand, backordered = subject.fill_status(variant, 20)
+        expect(on_hand).to eq 10
+        expect(backordered).to eq 10
+      end
+
+      it 'zero on_hand with all backordered' do
+        zero_stock_item = mock_model(StockItem,
+                                     count_on_hand: 0,
+                                     backorderable?: true)
+        expect(subject).to receive(:stock_item).with(variant).and_return(zero_stock_item)
+
+        on_hand, backordered = subject.fill_status(variant, 20)
+        expect(on_hand).to eq 0
+        expect(backordered).to eq 20
+      end
+
+      context 'when backordering is not allowed' do
+        before do
+          @stock_item = mock_model(StockItem, backorderable?: false)
+          expect(subject).to receive(:stock_item).with(variant).and_return(@stock_item)
+        end
+
+        it 'all on_hand' do
+          allow(@stock_item).to receive_messages(count_on_hand: 10)
+
+          on_hand, backordered = subject.fill_status(variant, 5)
+          expect(on_hand).to eq 5
+          expect(backordered).to eq 0
+        end
+
+        it 'some on_hand' do
+          allow(@stock_item).to receive_messages(count_on_hand: 10)
+
+          on_hand, backordered = subject.fill_status(variant, 20)
+          expect(on_hand).to eq 10
+          expect(backordered).to eq 0
+        end
+
+        it 'zero on_hand' do
+          allow(@stock_item).to receive_messages(count_on_hand: 0)
+
+          on_hand, backordered = subject.fill_status(variant, 20)
+          expect(on_hand).to eq 0
+          expect(backordered).to eq 0
+        end
+      end
+
+      context 'without stock_items' do
+        subject { create(:stock_location) }
+        let(:variant) { create(:base_variant) }
+
+        it 'zero on_hand and backordered' do
+          subject
+          variant.stock_items.destroy_all
+          on_hand, backordered = subject.fill_status(variant, 1)
+          expect(on_hand).to eq 0
+          expect(backordered).to eq 0
+        end
+      end
+    end
+
+    context '#state_text' do
+      context 'state is blank' do
+        subject { StockLocation.create(name: "testing", state: nil, state_name: 'virginia') }
+        specify { expect(subject.state_text).to eq('virginia') }
+      end
+
+      context 'both name and abbr is present' do
+        let(:state) { stub_model(Spree::State, name: 'virginia', abbr: 'va') }
+        subject { StockLocation.create(name: "testing", state: state, state_name: nil) }
+        specify { expect(subject.state_text).to eq('va') }
+      end
+
+      context 'only name is present' do
+        let(:state) { stub_model(Spree::State, name: 'virginia', abbr: nil) }
+        subject { StockLocation.create(name: "testing", state: state, state_name: nil) }
+        specify { expect(subject.state_text).to eq('virginia') }
+      end
+    end
+
+
+    describe "#move" do
+      let!(:variant) { create(:variant) }
+      def move
+        subject.move(variant, quantity)
+      end
+
+      context "no stock item exists" do
+        before { subject.stock_items.destroy_all }
+        context "positive movement" do
+          let(:quantity) { 1 }
+          it "creates a stock item" do
+            expect { move }.to change { subject.stock_items.count }.by 1
+          end
+        end
+
+        # We should not be creating stock items that do not exist
+        # for the sake of a negative movement.
+        context "negative movement" do
+          let(:quantity) { -1 }
+          it "raises an error" do
+            expect {
+              expect {
+                move
+              }.to raise_error StockLocation::InvalidMovementError
+            }.not_to change { subject.stock_items.count }
+          end
+        end
+
+      end
+    end
+  end
+end