solidus_core_devise_token_auth 2.8.0.alpha.0

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

@@ -0,0 +1,48 @@
+# 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
+        package1 = Package.new(stock_location)
+        4.times { package1.add inventory_unit1 }
+        8.times { package1.add inventory_unit2 }
+
+        package2 = Package.new(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

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

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

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

@@ -0,0 +1,347 @@
+# 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
+        Spree::Config.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
+        Spree::Config.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