solidus_core 2.10.0 → 2.11.0

data/spec/models/spree/stock_item_spec.rb

@@ -1,348 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.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 https://github.com/spree/spree/issues/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 https://github.com/spree/spree/issues/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
-      subject.discard
-    end
-  end
-
-  context "destroyed" do
-    before { subject.discard }
-
-    it "recreates stock item just fine" do
-      stock_location.stock_items.create!(variant: subject.variant)
-    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
-        stub_spree_preferences(inventory_cache_threshold: inventory_cache_threshold)
-      end
-
-      let(:inventory_cache_threshold) { 5 }
-
-      before do
-        subject.set_count_on_hand(existing_count_on_hand)
-        subject.variant.update_column(:updated_at, 1.day.ago)
-      end
-
-      context "beginning above threshold" do
-        let(:existing_count_on_hand) { 10 }
-
-        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 stays above threshold" do
-          expect do
-            subject.set_count_on_hand(8)
-          end.not_to change { subject.variant.updated_at }
-        end
-      end
-
-      context "beginning below threshold" do
-        let(:existing_count_on_hand) { 2 }
-
-        it "count on hand rises above threshold" do
-          expect do
-            subject.set_count_on_hand(7)
-          end.to change { subject.variant.updated_at }
-        end
-
-        it "count on hand stays below threshold" do
-          expect do
-            subject.set_count_on_hand(3)
-          end.to change { subject.variant.updated_at }
-        end
-      end
-    end
-
-    context "when deprecated binary_inventory_cache is used" do
-      before do
-        stub_spree_preferences(binary_inventory_cache: binary_inventory_cache)
-        allow(Spree::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(Spree::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(Spree::Deprecation).not_to have_received(:warn)
-        end
-      end
-    end
-  end
-
-  describe "#after_touch" do
-    before { subject.variant.update_column(:updated_at, 1.day.ago) }
-
-    it "touches its variant" do
-      expect do
-        subject.touch
-      end.to change { subject.variant.updated_at }
-    end
-  end
-
-  # Regression test for https://github.com/spree/spree/issues/4651
-  context "variant" do
-    it "can be found even if the variant is soft-deleted" do
-      subject.variant.discard
-      expect(subject.reload.variant).not_to be_nil
-    end
-  end
-
-  describe 'validations' do
-    before do
-      subject.backorderable = backorderable
-      subject.send(:count_on_hand=, count_on_hand)
-    end
-
-    describe 'count_on_hand' do
-      shared_examples_for 'valid count_on_hand' do
-        it 'has :no errors_on' do
-          expect(subject).to be_valid
-          expect(subject.errors[:count_on_hand].size).to eq(0)
-        end
-      end
-
-      shared_examples_for 'invalid count_on_hand' do
-        it 'has the correct error on count_on_hand' do
-          expect(subject).not_to be_valid
-          expect(subject.errors[:count_on_hand].size).to eq(1)
-          expect(subject.errors[:count_on_hand]).to include('must be greater than or equal to 0')
-        end
-      end
-
-      context 'when backorderable' do
-        let(:backorderable) { true }
-
-        context 'when count_on_hand is positive' do
-          let(:count_on_hand) { 3 }
-          it_should_behave_like "valid count_on_hand"
-        end
-
-        context 'when count_on_hand is negative' do
-          let(:count_on_hand) { -3 }
-
-          it_should_behave_like "valid count_on_hand"
-
-          it "can't be changed to not backorderable" do
-            expect(subject).to be_valid
-            subject.backorderable = false
-            expect(subject).not_to be_valid
-          end
-        end
-      end
-
-      context 'when not backorderable' do
-        let(:backorderable) { false }
-
-        context 'when count_on_hand is positive' do
-          let(:count_on_hand) { 3 }
-          it_should_behave_like "valid count_on_hand"
-        end
-
-        context 'when count_on_hand is negative' do
-          let(:count_on_hand) { -3 }
-
-          it_should_behave_like "invalid count_on_hand"
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/stock_location_spec.rb

@@ -1,288 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  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 }
-
-    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(0)
-      expect(stock_item).to be_nil
-    end
-
-    describe '#stock_item_or_create' do
-      before do
-        variant = create(:variant)
-        variant.stock_items.each(&:really_destroy!)
-        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
-        stock_item.set_count_on_hand(0)
-
-        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.update!(backorderable: false)
-        end
-
-        it 'all on_hand' do
-          stock_item.set_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
-          stock_item.set_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
-          stock_item.set_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.each(&:really_destroy!)
-          on_hand, backordered = subject.fill_status(variant, 1)
-          expect(on_hand).to eq 0
-          expect(backordered).to eq 0
-        end
-      end
-
-      context 'with soft-deleted stock_items' do
-        subject { create(:stock_location) }
-        let(:variant) { create(:base_variant) }
-
-        it 'zero on_hand and backordered' do
-          subject
-          variant.stock_items.discard_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.each(&:really_destroy!) }
-        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

data/spec/models/spree/stock_movement_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-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) }
-
-  it 'should belong to a stock item' do
-    expect(subject).to respond_to(:stock_item)
-  end
-
-  it 'is readonly unless new' do
-    subject.save
-    expect {
-      subject.save
-    }.to raise_error(ActiveRecord::ReadOnlyRecord)
-  end
-
-  it 'does not update count on hand when track inventory levels is false' do
-    stub_spree_preferences(track_inventory_levels: false)
-    subject.quantity = 1
-    subject.save
-    stock_item.reload
-    expect(stock_item.count_on_hand).to eq(10)
-  end
-
-  it 'does not update count on hand when variant inventory tracking is off' do
-    stock_item.variant.track_inventory = false
-    subject.quantity = 1
-    subject.save
-    stock_item.reload
-    expect(stock_item.count_on_hand).to eq(10)
-  end
-
-  context "when quantity is negative" do
-    context "after save" do
-      it "should decrement the stock item count on hand" do
-        subject.quantity = -1
-        subject.save
-        stock_item.reload
-        expect(stock_item.count_on_hand).to eq(9)
-      end
-    end
-  end
-
-  context "when quantity is positive" do
-    context "after save" do
-      it "should increment the stock item count on hand" do
-        subject.quantity = 1
-        subject.save
-        stock_item.reload
-        expect(stock_item.count_on_hand).to eq(11)
-      end
-    end
-  end
-end