solidus_core 2.10.5 → 2.11.0

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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    RSpec.describe ContentItem, type: :model do
-      let(:instance) { ContentItem.new(inventory_unit, state) }
-      let(:inventory_unit) { build(:inventory_unit) }
-      let(:state) { :on_hand }
-
-      describe '#variant' do
-        subject { instance.variant }
-        it { is_expected.to eq(inventory_unit.variant) }
-      end
-
-      describe '#weight' do
-        subject { instance.weight }
-        it { is_expected.to eq(0.to_d) }
-      end
-
-      describe '#line_item' do
-        subject { instance.line_item }
-        it { is_expected.to eq(inventory_unit.line_item) }
-      end
-
-      describe '#on_hand?' do
-        subject { instance.on_hand? }
-
-        context 'the state is on hand' do
-          it { is_expected.to eq(true) }
-        end
-
-        context 'the state is not on hand' do
-          let(:state) { 'foo' }
-          it { is_expected.to eq(false) }
-        end
-      end
-
-      describe '#backordered?' do
-        subject { instance.backordered? }
-
-        context 'the state is not backordered' do
-          let(:state) { 'foo' }
-          it { is_expected.to eq(false) }
-        end
-
-        context 'the state is backordered' do
-          let(:state) { :backordered }
-          it { is_expected.to eq(true) }
-        end
-      end
-
-      describe '#price' do
-        subject { instance.price }
-        it { is_expected.to eq(10.to_d) }
-      end
-
-      describe '#amount' do
-        subject { instance.amount }
-        it { is_expected.to eq(10.to_d) }
-      end
-
-      describe '#quantity' do
-        subject { instance.quantity }
-        it { is_expected.to eq(1) }
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    RSpec.describe Differentiator, type: :model do
-      let(:variant1) { mock_model(Variant) }
-      let(:variant2) { mock_model(Variant) }
-
-      let(:line_item1) { build(:line_item, variant: variant1, quantity: 2) }
-      let(:line_item2) { build(:line_item, variant: variant2, quantity: 2) }
-
-      let(:stock_location) { mock_model(StockLocation) }
-
-      let(:inventory_unit1) { build(:inventory_unit, variant: variant1, line_item: line_item1) }
-      let(:inventory_unit2) { build(:inventory_unit, variant: variant2, line_item: line_item2) }
-
-      let(:order) { mock_model(Order, line_items: [line_item1, line_item2]) }
-
-      let(:package1) do
-        Package.new(stock_location).tap { |package| package.add(inventory_unit1) }
-      end
-
-      let(:package2) do
-        Package.new(stock_location).tap { |package| package.add(inventory_unit2) }
-      end
-
-      let(:packages) { [package1, package2] }
-
-      subject { Differentiator.new(order, packages) }
-
-      it { is_expected.to be_missing }
-
-      it 'calculates the missing items' do
-        expect(subject.missing[variant1]).to eq 1
-        expect(subject.missing[variant2]).to eq 1
-      end
-    end
-  end
-end

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

@@ -1,241 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    RSpec.describe Estimator, type: :model do
-      let(:shipping_rate) { 4.00 }
-      let!(:shipping_method) { create(:shipping_method, cost: shipping_rate, currency: currency) }
-      let(:package) do
-        build(:stock_package, contents: inventory_units.map { |unit| ContentItem.new(unit) }).tap do |package|
-          package.shipment = package.to_shipment
-        end
-      end
-      let(:order) { create(:order_with_line_items, shipping_method: shipping_method) }
-      let(:inventory_units) { order.inventory_units }
-
-      subject { Estimator.new }
-
-      context "#shipping rates" do
-        before(:each) do
-          shipping_method.zones.first.members.create(zoneable: order.ship_address.country)
-        end
-
-        let(:currency) { "USD" }
-
-        context 'without a shipment' do
-          before { package.shipment = nil }
-          it 'raises an error' do
-            expect {
-              subject.shipping_rates(package)
-            }.to raise_error(Spree::Stock::Estimator::ShipmentRequired)
-          end
-        end
-
-        context 'without an order' do
-          before { package.shipment.order = nil }
-          it 'raises an error' do
-            expect {
-              subject.shipping_rates(package)
-            }.to raise_error(Spree::Stock::Estimator::OrderRequired)
-          end
-        end
-
-        shared_examples_for "shipping rate matches" do
-          it "returns shipping rates" do
-            shipping_rates = subject.shipping_rates(package)
-            expect(shipping_rates.first.cost).to eq 4.00
-          end
-        end
-
-        shared_examples_for "shipping rate doesn't match" do
-          it "does not return shipping rates" do
-            shipping_rates = subject.shipping_rates(package)
-            expect(shipping_rates).to eq([])
-          end
-        end
-
-        context "when the order's ship address is in the same zone" do
-          it_should_behave_like "shipping rate matches"
-        end
-
-        context "when the order's ship address is in a different zone" do
-          before { shipping_method.zones.each{ |zone| zone.members.delete_all } }
-          it_should_behave_like "shipping rate doesn't match"
-        end
-
-        context "when the currency is nil" do
-          let(:currency) { nil }
-          it_should_behave_like "shipping rate matches"
-        end
-
-        context "when the currency is an empty string" do
-          let(:currency) { "" }
-          it_should_behave_like "shipping rate matches"
-        end
-
-        context "when the current matches the order's currency" do
-          it_should_behave_like "shipping rate matches"
-        end
-
-        context "if the currency is different than the order's currency" do
-          let(:currency) { "GBP" }
-          it_should_behave_like "shipping rate doesn't match"
-        end
-
-        it "sorts shipping rates by cost" do
-          ShippingMethod.all.each(&:really_destroy!)
-          create(:shipping_method, cost: 5)
-          create(:shipping_method, cost: 3)
-          create(:shipping_method, cost: 4)
-
-          expect(subject.shipping_rates(package).map(&:cost)).to eq [3.00, 4.00, 5.00]
-        end
-
-        context "general shipping methods" do
-          before { Spree::ShippingMethod.all.each(&:really_destroy!) }
-
-          context 'with two shipping methods of different cost' do
-            let!(:shipping_methods) do
-              [
-                create(:shipping_method, cost: 5),
-                create(:shipping_method, cost: 3)
-              ]
-            end
-
-            it "selects the most affordable shipping rate" do
-              expect(subject.shipping_rates(package).sort_by(&:cost).map(&:selected)).to eq [true, false]
-            end
-          end
-
-          context 'with one of the shipping methods having nil cost' do
-            let!(:shipping_methods) do
-              [
-                create(:shipping_method, cost: 1),
-                create(:shipping_method, cost: nil)
-              ]
-            end
-
-            it "selects the most affordable shipping rate and doesn't raise exception over nil cost" do
-              allow(shipping_methods[1]).to receive_message_chain(:calculator, :compute).and_return(nil)
-              allow(subject).to receive(:shipping_methods).and_return(shipping_methods)
-
-              expect(subject.shipping_rates(package).map(&:shipping_method)).to eq([shipping_methods[0]])
-            end
-          end
-        end
-
-        context "involves backend only shipping methods" do
-          before{ Spree::ShippingMethod.all.each(&:really_destroy!) }
-          let!(:backend_method) { create(:shipping_method, available_to_users: false, cost: 0.00) }
-          let!(:generic_method) { create(:shipping_method, cost: 5.00) }
-
-          it "does not return backend rates at all" do
-            expect(subject.shipping_rates(package).map(&:shipping_method_id)).to eq([generic_method.id])
-          end
-
-          # regression for https://github.com/spree/spree/issues/3287
-          it "doesn't select backend rates even if they're more affordable" do
-            expect(subject.shipping_rates(package).map(&:selected)).to eq [true]
-          end
-        end
-
-        context "excludes shipping methods from other stores" do
-          before{ Spree::ShippingMethod.all.each(&:really_destroy!) }
-
-          let!(:other_method) do
-            create(
-              :shipping_method,
-              cost: 0.00,
-              stores: [build(:store, name: "Other")]
-            )
-          end
-
-          let!(:main_method) do
-            create(
-              :shipping_method,
-              cost: 5.00,
-              stores: [order.store]
-            )
-          end
-
-          it "does not return the other rate at all" do
-            expect(subject.shipping_rates(package).map(&:shipping_method_id)).to eq([main_method.id])
-          end
-
-          it "doesn't select the other rate even if it's more affordable" do
-            expect(subject.shipping_rates(package).map(&:selected)).to eq [true]
-          end
-        end
-
-        context "includes tax adjustments if applicable" do
-          let(:zone) { create(:zone, countries: [order.tax_address.country]) }
-
-          let!(:tax_rate) { create(:tax_rate, zone: zone) }
-
-          before do
-            shipping_method.update!(tax_category: tax_rate.tax_categories.first)
-          end
-
-          it "links the shipping rate and the tax rate" do
-            shipping_rates = subject.shipping_rates(package)
-            expect(shipping_rates.first.taxes.first.tax_rate).to eq(tax_rate)
-          end
-        end
-
-        it 'uses the configured shipping rate selector' do
-          shipping_rate = build(:shipping_rate)
-          allow(Spree::ShippingRate).to receive(:new).and_return(shipping_rate)
-
-          selector_class = Class.new do
-            def initialize(_); end;
-
-            def find_default
-              Spree::ShippingRate.new
-            end
-          end
-          stub_spree_preferences(shipping_rate_selector_class: selector_class)
-
-          subject.shipping_rates(package)
-
-          expect(shipping_rate.selected).to eq(true)
-        end
-
-        it 'uses the configured shipping rate sorter' do
-          class Spree::Stock::TestSorter
-            def initialize(_rates)
-            end
-          end
-
-          stub_spree_preferences(shipping_rate_sorter_class: Spree::Stock::TestSorter)
-
-          sorter = double(:sorter, sort: nil)
-          allow(Spree::Stock::TestSorter).to receive(:new) { sorter }
-
-          subject.shipping_rates(package)
-
-          expect(sorter).to have_received(:sort)
-        end
-
-        it 'uses the configured shipping rate taxer' do
-          class Spree::Tax::TestTaxCalculator
-            def initialize(_order)
-            end
-
-            def calculate(_shipping_rate)
-              [
-                Spree::Tax::ItemTax.new(label: "TAX", amount: 5)
-              ]
-            end
-          end
-
-          stub_spree_preferences(shipping_rate_tax_calculator_class: Spree::Tax::TestTaxCalculator)
-
-          expect(Spree::Tax::TestTaxCalculator).to receive(:new).and_call_original
-          subject.shipping_rates(package)
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    RSpec.describe InventoryUnitBuilder, type: :model do
-      let(:line_item_1) { build(:line_item) }
-      let(:line_item_2) { build(:line_item, quantity: 2) }
-      let(:order) { build(:order, line_items: [line_item_1, line_item_2]) }
-
-      subject { InventoryUnitBuilder.new(order) }
-
-      describe "#units" do
-        it "returns an inventory unit for each quantity for the order's line items" do
-          units = subject.units
-          expect(units.count).to eq 3
-          expect(units.first.line_item).to eq line_item_1
-          expect(units.first.variant).to eq line_item_1.variant
-
-          expect(units[1].line_item).to eq line_item_2
-          expect(units[1].variant).to eq line_item_2.variant
-
-          expect(units[2].line_item).to eq line_item_2
-          expect(units[2].variant).to eq line_item_2.variant
-        end
-
-        it "builds the inventory units as pending" do
-          expect(subject.units.map(&:pending).uniq).to eq [true]
-        end
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    RSpec.describe InventoryUnitsFinalizer, type: :model do
-      context "when finalizing an order with one line_item" do
-        let(:order)          { build(:order_with_line_items) }
-        let(:inventory_unit) { build(:inventory_unit, order: order, variant: order.line_items.first.variant, shipment: order.shipments.first) }
-        let(:stock_item) { inventory_unit.variant.stock_items.first }
-
-        before do
-          stock_item.set_count_on_hand(10)
-          stock_item.update!(backorderable: false)
-          inventory_unit.update!(pending: true)
-        end
-
-        subject { described_class.new([inventory_unit]).run! }
-
-        it "updates the associated inventory units" do
-          inventory_unit.update_columns(updated_at: 1.hour.ago)
-          expect { subject }.to change { inventory_unit.reload.updated_at }
-        end
-
-        it "updates the inventory units to not be pending" do
-          expect { subject }.to change { inventory_unit.reload.pending }.to(false)
-        end
-
-        it "unstocks the variant" do
-          expect { subject }.to change { stock_item.reload.count_on_hand }.from(10).to(9)
-        end
-      end
-
-      context "when finalizing an order with multiple line_items" do
-        let(:order)          { build(:order_with_line_items, line_items_count: 2) }
-        let(:inventory_unit) { build(:inventory_unit, order: order, variant: order.line_items.first.variant, shipment: order.shipments.first) }
-        let(:inventory_unit_2) { build(:inventory_unit, order: order, variant: order.line_items.second.variant, shipment: order.shipments.first) }
-        let(:stock_item) { inventory_unit.variant.stock_items.first }
-        let(:stock_item_2) { inventory_unit.variant.stock_items.first }
-
-        before do
-          stock_item.set_count_on_hand(10)
-          stock_item_2.set_count_on_hand(10)
-          inventory_unit.update!(pending: true)
-          inventory_unit_2.update!(pending: true)
-        end
-
-        subject { described_class.new([inventory_unit, inventory_unit_2]).run! }
-
-        it "unstocks the variant with the correct quantity" do
-          expect { subject }.to change { stock_item.reload.count_on_hand }.from(10).to(9)
-          .and change { stock_item_2.reload.count_on_hand }.from(10).to(9)
-        end
-      end
-    end
-  end
-end