solidus_core 2.10.5 → 3.0.8

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

data/spec/models/spree/stock/location_filter/active_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    module LocationFilter
-      RSpec.describe Active, type: :model do
-        subject { described_class.new(stock_locations, order) }
-
-        let!(:active_stock_location) { create(:stock_location) }
-        let!(:inactive_stock_location) { create(:stock_location, active: false) }
-        let(:stock_locations) { Spree::StockLocation.all }
-        let(:order) { instance_double('Spree::Order') }
-
-        it 'returns only active stock locations' do
-          expect(subject.filter).to eq([active_stock_location])
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/stock/location_sorter/default_first_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    module LocationSorter
-      RSpec.describe DefaultFirst, type: :model do
-        subject { described_class.new(stock_locations) }
-
-        let!(:first_stock_location) { create(:stock_location, default: false) }
-        let!(:second_stock_location) { create(:stock_location, default: true) }
-        let(:stock_locations) { Spree::StockLocation.all }
-        let(:sorted_stock_locations) { stock_locations.reverse }
-
-        it 'returns the default stock location first' do
-          expect(subject.sort).to eq(sorted_stock_locations)
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/stock/location_sorter/unsorted_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    module LocationSorter
-      RSpec.describe Unsorted, type: :model do
-        subject { described_class.new(stock_locations) }
-
-        let!(:first_stock_location) { create(:stock_location) }
-        let!(:second_stock_location) { create(:stock_location) }
-        let(:stock_locations) { Spree::StockLocation.all }
-
-        it 'returns the original stock locations unsorted' do
-          expect(subject.sort).to eq(stock_locations)
-        end
-      end
-    end
-  end
-end

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

@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    RSpec.describe Package, type: :model do
-      let(:variant) { build(:variant, weight: 25.0) }
-      let(:stock_location) { build(:stock_location) }
-      let(:order) { build(:order) }
-      let(:line_item) { build(:line_item, order: order) }
-
-      subject { Package.new(stock_location) }
-
-      def build_inventory_unit
-        build(:inventory_unit, variant: variant, line_item: line_item)
-      end
-
-      it 'calculates the weight of all the contents' do
-        4.times { subject.add build_inventory_unit }
-        expect(subject.weight).to eq(100.0)
-      end
-
-      it 'filters by on_hand and backordered' do
-        4.times { subject.add build_inventory_unit }
-        3.times { subject.add build_inventory_unit, :backordered }
-        expect(subject.on_hand.count).to eq 4
-        expect(subject.backordered.count).to eq 3
-      end
-
-      it 'calculates the quantity by state' do
-        4.times { subject.add build_inventory_unit }
-        3.times { subject.add build_inventory_unit, :backordered }
-
-        expect(subject.quantity).to eq 7
-        expect(subject.quantity(:on_hand)).to eq 4
-        expect(subject.quantity(:backordered)).to eq 3
-      end
-
-      it 'returns nil for content item not found' do
-        unit = build_inventory_unit
-        item = subject.find_item(unit, :on_hand)
-        expect(item).to be_nil
-      end
-
-      it 'finds content item for an inventory unit' do
-        unit = build_inventory_unit
-        subject.add unit
-        item = subject.find_item(unit, :on_hand)
-        expect(item.quantity).to eq 1
-      end
-
-      it 'builds the correct list of shipping methods based on stock location and categories' do
-        category_one = create(:shipping_category)
-        category_two = create(:shipping_category)
-        method_one   = create(:shipping_method, available_to_all: true)
-        method_two   = create(:shipping_method, stock_locations: [stock_location])
-        method_one.shipping_categories = [category_one, category_two]
-        method_two.shipping_categories = [category_one, category_two]
-        variant_one = mock_model(Variant, shipping_category_id: category_one.id)
-        variant_two = mock_model(Variant, shipping_category_id: category_two.id)
-        variant_three = mock_model(Variant, shipping_category_id: nil)
-        contents = [ContentItem.new(build(:inventory_unit, variant: variant_one)),
-                    ContentItem.new(build(:inventory_unit, variant: variant_one)),
-                    ContentItem.new(build(:inventory_unit, variant: variant_two)),
-                    ContentItem.new(build(:inventory_unit, variant: variant_three))]
-
-        package = Package.new(stock_location, contents)
-        expect(package.shipping_methods).to match_array([method_one, method_two])
-      end
-      # Contains regression test for https://github.com/spree/spree/issues/2804
-      it 'builds a list of shipping methods common to all categories' do
-        category_one = create(:shipping_category)
-        category_two = create(:shipping_category)
-        method_one   = create(:shipping_method)
-        method_two   = create(:shipping_method)
-        method_one.shipping_categories = [category_one, category_two]
-        method_two.shipping_categories = [category_one]
-        variant_one = mock_model(Variant, shipping_category_id: category_one.id)
-        variant_two = mock_model(Variant, shipping_category_id: category_two.id)
-        variant_three = mock_model(Variant, shipping_category_id: nil)
-        contents = [ContentItem.new(build(:inventory_unit, variant: variant_one)),
-                    ContentItem.new(build(:inventory_unit, variant: variant_one)),
-                    ContentItem.new(build(:inventory_unit, variant: variant_two)),
-                    ContentItem.new(build(:inventory_unit, variant: variant_three))]
-
-        package = Package.new(stock_location, contents)
-        expect(package.shipping_methods).to match_array([method_one])
-      end
-
-      it 'builds an empty list of shipping methods when no categories' do
-        variant  = mock_model(Variant, shipping_category_id: nil)
-        contents = [ContentItem.new(build(:inventory_unit, variant: variant))]
-        package  = Package.new(stock_location, contents)
-        expect(package.shipping_methods).to be_empty
-      end
-
-      it "can convert to a shipment" do
-        2.times { subject.add build_inventory_unit }
-        subject.add build_inventory_unit, :backordered
-
-        shipping_method = build(:shipping_method)
-
-        shipment = subject.to_shipment
-        shipment.shipping_rates = [Spree::ShippingRate.new(shipping_method: shipping_method, cost: 10.00, selected: true)]
-        expect(shipment.stock_location).to eq subject.stock_location
-        expect(shipment.inventory_units.size).to eq 3
-
-        first_unit = shipment.inventory_units.first
-        expect(first_unit.variant).to eq variant
-        expect(first_unit.state).to eq 'on_hand'
-        expect(first_unit).to be_pending
-
-        last_unit = shipment.inventory_units.last
-        expect(last_unit.variant).to eq variant
-        expect(last_unit.state).to eq 'backordered'
-
-        expect(shipment.shipping_method).to eq shipping_method
-      end
-
-      it 'does not add an inventory unit to a package twice' do
-        # since inventory units currently don't have a quantity
-        unit = build_inventory_unit
-        subject.add unit
-        subject.add unit
-        expect(subject.quantity).to eq 1
-        expect(subject.contents.first.inventory_unit).to eq unit
-        expect(subject.contents.first.quantity).to eq 1
-      end
-
-      describe "#add_multiple" do
-        it "adds multiple inventory units" do
-          expect { subject.add_multiple [build_inventory_unit, build_inventory_unit] }.to change { subject.quantity }.by(2)
-        end
-
-        it "allows adding with a state" do
-          expect { subject.add_multiple [build_inventory_unit, build_inventory_unit], :backordered }.to change { subject.backordered.count }.by(2)
-        end
-
-        it "defaults to adding with the on hand state" do
-          expect { subject.add_multiple [build_inventory_unit, build_inventory_unit] }.to change { subject.on_hand.count }.by(2)
-        end
-      end
-
-      describe "#remove" do
-        let(:unit) { build_inventory_unit }
-        context "there is a content item for the inventory unit" do
-          before { subject.add unit }
-
-          it "removes that content item" do
-            expect { subject.remove(unit) }.to change { subject.quantity }.by(-1)
-            expect(subject.contents.map(&:inventory_unit)).not_to include unit
-          end
-        end
-
-        context "there is no content item for the inventory unit" do
-          it "doesn't change the set of content items" do
-            expect { subject.remove(unit) }.not_to change { subject.quantity }
-          end
-        end
-      end
-
-      describe "#order" do
-        let(:unit) { build_inventory_unit }
-        context "there is an inventory unit" do
-          before { subject.add unit }
-
-          it "returns an order" do
-            expect(subject.order).to be_a_kind_of Spree::Order
-            expect(subject.order).to eq order
-          end
-        end
-
-        context "there is no inventory unit" do
-          it "returns nil" do
-            expect(subject.order).to eq nil
-          end
-        end
-      end
-    end
-  end
-end