solidus_core_devise_token_auth 2.8.0.alpha.0

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

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree::Stock
+  RSpec.describe Availability do
+    let(:variants) { Spree::Variant.all.to_a }
+    let(:infinity) { Float::INFINITY }
+
+    let(:availability) { described_class.new(variants: variants) }
+
+    let!(:stock_location1) { create(:stock_location) }
+
+    subject { availability }
+
+    describe "#on_hand_by_stock_location_id" do
+      subject { availability.on_hand_by_stock_location_id }
+
+      context 'with a single variant' do
+        let!(:variant) { create(:master_variant) }
+        let(:stock_item) { variant.stock_items[0] }
+
+        context 'with count_on_hand positive' do
+          before { stock_item.set_count_on_hand(2) }
+
+          it "returns the correct value" do
+            expect(subject).to eq(stock_location1.id => Spree::StockQuantities.new(variant => 2))
+          end
+
+          context 'and backorderable false' do
+            before { stock_item.update!(backorderable: false) }
+
+            it "returns the correct value" do
+              expect(subject).to eq(stock_location1.id => Spree::StockQuantities.new(variant => 2))
+            end
+          end
+        end
+
+        context 'with count_on_hand 0' do
+          before { stock_item.set_count_on_hand(0) }
+
+          it "returns zero on_hand" do
+            expect(subject).to eq(stock_location1.id => Spree::StockQuantities.new(variant => 0))
+          end
+        end
+
+        context 'with count_on_hand negative' do
+          before { stock_item.set_count_on_hand(-1) }
+
+          it "returns zero on_hand" do
+            expect(subject).to eq(stock_location1.id => Spree::StockQuantities.new(variant => 0))
+          end
+        end
+
+        context 'with no stock_item' do
+          before { stock_item.really_destroy! }
+
+          it "returns empty hash" do
+            expect(subject).to eq({})
+          end
+        end
+
+        context 'with soft-deleted stock_item' do
+          before { stock_item.discard }
+
+          it "returns empty hash" do
+            expect(subject).to eq({})
+          end
+        end
+
+        context 'with track_inventory=false' do
+          before { variant.update!(track_inventory: false) }
+
+          it "has infinite inventory " do
+            expect(subject).to eq(stock_location1.id => Spree::StockQuantities.new(variant => infinity))
+          end
+        end
+
+        context 'with config.track_inventory_levels=false' do
+          before { Spree::Config.track_inventory_levels = false }
+
+          it "has infinite inventory " do
+            expect(subject).to eq(stock_location1.id => Spree::StockQuantities.new(variant => infinity))
+          end
+        end
+      end
+    end
+
+    describe "#backorderable_by_stock_location_id" do
+      subject { availability.backorderable_by_stock_location_id }
+
+      context 'with a single variant' do
+        let!(:variant) { create(:master_variant) }
+        let(:stock_item) { variant.stock_items[0] }
+
+        context 'with backorderable false' do
+          before { stock_item.update!(backorderable: false) }
+
+          context 'and positive count_on_hand' do
+            before { stock_item.set_count_on_hand(2) }
+            it { is_expected.to eq({}) }
+          end
+
+          context 'and 0 count_on_hand' do
+            before { stock_item.set_count_on_hand(0) }
+            it { is_expected.to eq({}) }
+          end
+        end
+
+        context 'with backorderable true' do
+          before { stock_item.update!(backorderable: true) }
+
+          context 'and positive count_on_hand' do
+            before { stock_item.set_count_on_hand(2) }
+            it { is_expected.to eq(stock_location1.id => Spree::StockQuantities.new(variant => infinity)) }
+          end
+
+          context 'and 0 count_on_hand' do
+            before { stock_item.set_count_on_hand(0) }
+            it { is_expected.to eq(stock_location1.id => Spree::StockQuantities.new(variant => infinity)) }
+          end
+
+          context 'and negative count_on_hand' do
+            before { stock_item.set_count_on_hand(-1) }
+            it { is_expected.to eq(stock_location1.id => Spree::StockQuantities.new(variant => infinity)) }
+          end
+        end
+
+        context 'with soft-deleted stock_item' do
+          before { stock_item.discard }
+
+          it { is_expected.to eq({}) }
+        end
+
+        context 'with no stock_item' do
+          before { stock_item.really_destroy! }
+
+          it { is_expected.to eq({}) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  module Stock
+    RSpec.describe AvailabilityValidator do
+      let(:validator) { Spree::Stock::AvailabilityValidator.new }
+
+      subject { validator.validate(line_item) }
+
+      shared_examples_for "fails validation" do
+        it "returns false" do
+          expect(subject).to eq false
+        end
+
+        it "adds a validation error" do
+          subject
+          display_name = line_item.variant.name.to_s
+          display_name += " (#{line_item.variant.options_text})" unless line_item.variant.options_text.blank?
+          expect(line_item.errors).to match_array ["Quantity selected of #{display_name.inspect} is not available."]
+        end
+      end
+
+      shared_examples_for "passes validation" do
+        it "returns true" do
+          expect(subject).to eq true
+        end
+
+        it "doesn't add a validation error" do
+          subject
+          expect(line_item.errors).to be_empty
+        end
+      end
+
+      context "line_item is not part of a shipment" do
+        let(:line_item) { create(:line_item) }
+
+        context "has stock in all stock locations" do
+          before do
+            Spree::StockItem.where(variant_id: line_item.variant_id).update_all(count_on_hand: 10, backorderable: false)
+          end
+
+          include_examples "passes validation"
+        end
+
+        context "doesn't have stock in any stock location" do
+          before do
+            Spree::StockItem.where(variant_id: line_item.variant_id).update_all(count_on_hand: 0, backorderable: false)
+          end
+
+          include_examples "fails validation"
+        end
+      end
+
+      context "line_item is part of a shipment" do
+        let!(:order) { create(:order_with_line_items) }
+
+        context "has stock in one stock location" do
+          let(:line_item)         { order.line_items.first }
+
+          before do
+            line_item.variant.stock_items.update_all(count_on_hand: 10, backorderable: false)
+          end
+
+          include_examples "passes validation"
+        end
+
+        context "with stock in multiple locations" do
+          let(:line_item)         { order.line_items.first }
+          let(:variant)           { line_item.variant }
+          let!(:stock_location_1) { create(:stock_location, name: "Test Warehouse", active: false) }
+
+          before do
+            shipment = order.shipments.create(stock_location: stock_location_1)
+            order.contents.add(variant, 1, shipment: shipment)
+          end
+
+          context "but no stock in either location" do
+            before do
+              variant.stock_items.update_all(count_on_hand: 0, backorderable: false)
+            end
+            include_examples "fails validation"
+          end
+
+          context "but no stock in one location" do
+            before do
+              stock_location_1.stock_items.update_all(count_on_hand: 0, backorderable: false)
+            end
+
+            include_examples "fails validation"
+          end
+
+          context "with enough stock only across locations" do
+            before do
+              variant.stock_items.update_all(count_on_hand: 1, backorderable: false)
+            end
+            include_examples "passes validation"
+          end
+
+          context "but inventory units are finalized" do
+            before do
+              order.inventory_units.update_all(pending: false)
+            end
+
+            include_examples "passes validation"
+          end
+        end
+      end
+
+      context "line_item is split across two shipments" do
+        let!(:order) { create(:order_with_line_items) }
+        let(:line_item) { order.line_items.first }
+        let(:variant) { line_item.variant }
+        let(:stock_location) { order.shipments.first.stock_location }
+
+        before do
+          shipment2 = order.shipments.create!(stock_location: order.shipments.first.stock_location)
+          order.contents.add(variant, 1, shipment: shipment2)
+          variant.stock_items.first.update_columns(count_on_hand: count_on_hand, backorderable: false)
+        end
+
+        context "and there is just enough stock" do
+          let(:count_on_hand) { 2 }
+          include_examples "passes validation"
+        end
+
+        context "and there is not enough stock" do
+          let(:count_on_hand) { 1 }
+          include_examples "fails validation"
+        end
+
+        context "and there is no available stock" do
+          let(:count_on_hand) { 0 }
+          include_examples "fails validation"
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,41 @@
+# 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 { |p| p.add(inventory_unit1) }
+      end
+
+      let(:package2) do
+        Package.new(stock_location).tap { |p| p.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

@@ -0,0 +1,240 @@
+# 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 { |i| ContentItem.new(i) }).tap do |p|
+          p.shipment = p.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{ |z| z.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
+          Spree::Config.shipping_rate_selector_class = selector_class
+
+          subject.shipping_rates(package)
+
+          expect(shipping_rate.selected).to eq(true)
+
+          Spree::Config.shipping_rate_selector_class = nil
+        end
+
+        it 'uses the configured shipping rate sorter' do
+          class Spree::Stock::TestSorter; end;
+          Spree::Config.shipping_rate_sorter_class = Spree::Stock::TestSorter
+
+          sorter = double(:sorter, sort: nil)
+          allow(Spree::Stock::TestSorter).to receive(:new).and_return(sorter)
+
+          subject.shipping_rates(package)
+
+          expect(sorter).to have_received(:sort)
+
+          Spree::Config.shipping_rate_sorter_class = nil
+        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
+          Spree::Config.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

@@ -0,0 +1,34 @@
+# 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/location_sorter/default_first_spec.rb

@@ -0,0 +1,20 @@
+# 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(:stock_locations) { OpenStruct.new(order_default: sorted_stock_locations) }
+        let(:sorted_stock_locations) { instance_double('Spree::StockLocation::ActiveRecord_Relation') }
+
+        it 'returns the default stock location first' do
+          expect(subject.sort).to eq(sorted_stock_locations)
+        end
+      end
+    end
+  end
+end