solidus_core 2.10.2 → 2.11.0

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

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

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

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

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

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

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

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

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

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

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