solidus_core 2.10.5 → 3.0.8

data/spec/models/spree/state_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::State, type: :model do
-  describe '.with_name_or_abbr' do
-    subject do
-      Spree::State.with_name_or_abbr(search_term)
-    end
-
-    let!(:state) { create(:state, name: "California", abbr: "CA") }
-
-    context 'by invalid term' do
-      let(:search_term) { 'NonExistent' }
-      it { is_expected.to be_empty }
-    end
-
-    context 'by name' do
-      let(:search_term) { 'California' }
-      it { is_expected.to include(state) }
-    end
-
-    context 'by abbr' do
-      let(:search_term) { 'CA' }
-      it { is_expected.to include(state) }
-    end
-
-    context 'by case-insensitive abbr' do
-      let(:search_term) { 'CaLiFoRnIa' }
-      it { is_expected.to include(state) }
-    end
-
-    context 'by case-insensitive abbr' do
-      let(:search_term) { 'cA' }
-      it { is_expected.to include(state) }
-    end
-  end
-
-  it "can find all states group by country id" do
-    state = create(:state)
-    expect(Spree::State.states_group_by_country_id).to eq({ state.country_id.to_s => [[state.id, state.name]] })
-  end
-end

data/spec/models/spree/stock/allocator/on_hand_first_spec.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Stock
-    module Allocator
-      RSpec.describe OnHandFirst, type: :model do
-        subject { described_class.new(availability) }
-
-        let(:availability) { double(Spree::Stock::Availability) }
-
-        let!(:default_stock_location) { create(:stock_location, default: true, backorderable_default: false) }
-        let!(:backorderable_stock_location) { create(:stock_location) }
-
-        let(:first_variant) { create(:variant) }
-        let(:second_variant) { create(:variant) }
-
-        let(:desired_quantities) do
-          quantities = {}
-          quantities[first_variant] = first_variant_desired
-          quantities[second_variant] = second_variant_desired
-          quantities
-        end
-
-        let(:desired) { Spree::StockQuantities.new(desired_quantities) }
-
-        describe '#allocate_inventory' do
-          let(:default_on_hand_availability) do
-            quantities = {}
-            quantities[first_variant] = first_variant_default_availability
-            quantities[second_variant] = second_variant_default_availability
-            quantities
-          end
-
-          let(:dropship_on_hand_availability) do
-            quantities = {}
-            quantities[first_variant] = first_variant_dropship_availability
-            quantities[second_variant] = second_variant_dropship_availability
-            quantities
-          end
-
-          let(:on_hand_by_stock_location_id) do
-            availability = {}
-            availability[default_stock_location.id] = Spree::StockQuantities.new(default_on_hand_availability)
-            availability[backorderable_stock_location.id] = Spree::StockQuantities.new(dropship_on_hand_availability)
-            availability
-          end
-
-          let(:dropship_backorderable_availability) do
-            quantities = {}
-            quantities[first_variant] = Float::INFINITY
-            quantities[second_variant] = Float::INFINITY
-            quantities
-          end
-
-          let(:backorderable_by_stock_location_id) do
-            availability = {}
-            availability[backorderable_stock_location.id] = Spree::StockQuantities.new(dropship_backorderable_availability)
-            availability
-          end
-
-          before do
-            allow(availability).to receive(:on_hand_by_stock_location_id)
-              .and_return(on_hand_by_stock_location_id)
-
-            allow(availability).to receive(:backorderable_by_stock_location_id)
-              .and_return(backorderable_by_stock_location_id)
-          end
-
-          context 'when default stock location has enough items' do
-            let(:first_variant_default_availability) { 100 }
-            let(:second_variant_default_availability) { 100 }
-            let(:first_variant_dropship_availability) { 0 }
-            let(:second_variant_dropship_availability) { 0 }
-            let(:first_variant_desired) { 30 }
-            let(:second_variant_desired) { 5 }
-
-            it 'allocates all the desired units on the default stock location' do
-              on_hand_packages, backordered_packages, leftover = subject.allocate_inventory(desired)
-
-              expect(on_hand_packages[default_stock_location.id][first_variant]).to eq(30)
-              expect(on_hand_packages[default_stock_location.id][second_variant]).to eq(5)
-              expect(on_hand_packages[backorderable_stock_location.id][first_variant]).to eq(0)
-              expect(on_hand_packages[backorderable_stock_location.id][second_variant]).to eq(0)
-
-              expect(backordered_packages[backorderable_stock_location.id][first_variant]).to eq(0)
-              expect(backordered_packages[backorderable_stock_location.id][second_variant]).to eq(0)
-
-              expect(leftover[first_variant]).to eq(0)
-              expect(leftover[second_variant]).to eq(0)
-            end
-          end
-
-          context 'when default stock location hasn\'t enough items' do
-            let(:first_variant_default_availability) { 10 }
-            let(:second_variant_default_availability) { 10 }
-
-            let(:first_variant_desired) { 15 }
-            let(:second_variant_desired) { 5 }
-
-            context 'when dropship stock location has enough items' do
-              let(:first_variant_dropship_availability) { 20 }
-              let(:second_variant_dropship_availability) { 0 }
-
-              it 'allocates all the desired units on the stock locations while stocks last' do
-                on_hand_packages, backordered_packages, leftover = subject.allocate_inventory(desired)
-
-                expect(on_hand_packages[default_stock_location.id][first_variant]).to eq(10)
-                expect(on_hand_packages[default_stock_location.id][second_variant]).to eq(5)
-                expect(on_hand_packages[backorderable_stock_location.id][first_variant]).to eq(5)
-                expect(on_hand_packages[backorderable_stock_location.id][second_variant]).to eq(0)
-
-                expect(backordered_packages[backorderable_stock_location.id][first_variant]).to eq(0)
-                expect(backordered_packages[backorderable_stock_location.id][second_variant]).to eq(0)
-
-                expect(leftover[first_variant]).to eq(0)
-                expect(leftover[second_variant]).to eq(0)
-              end
-            end
-
-            context 'when dropship stock location hasn\'t enough items' do
-              let(:first_variant_dropship_availability) { 2 }
-              let(:second_variant_dropship_availability) { 0 }
-
-              it 'allocates all the desired units on the stock locations while stocks last' do
-                on_hand_packages, backordered_packages, leftover = subject.allocate_inventory(desired)
-
-                expect(on_hand_packages[default_stock_location.id][first_variant]).to eq(10)
-                expect(on_hand_packages[default_stock_location.id][second_variant]).to eq(5)
-                expect(on_hand_packages[backorderable_stock_location.id][first_variant]).to eq(2)
-                expect(on_hand_packages[backorderable_stock_location.id][second_variant]).to eq(0)
-
-                expect(backordered_packages[backorderable_stock_location.id][first_variant]).to eq(3)
-                expect(backordered_packages[backorderable_stock_location.id][second_variant]).to eq(0)
-
-                expect(leftover[first_variant]).to eq(0)
-                expect(leftover[second_variant]).to eq(0)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,143 +0,0 @@
-# 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 { stub_spree_preferences(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

@@ -1,140 +0,0 @@
-# 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
-          shipment_two = order.shipments.create!(stock_location: order.shipments.first.stock_location)
-          order.contents.add(variant, 1, shipment: shipment_two)
-          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

@@ -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