spree_core 3.2.9 → 3.3.0.rc1

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    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,202 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    describe Estimator, type: :model do
+      let!(:shipping_method) { create(:shipping_method) }
+      let(:package) { build(:stock_package, contents: inventory_units.map { |i| ContentItem.new(inventory_unit) }) }
+      let(:order) { build(:order_with_line_items) }
+      let(:inventory_units) { order.inventory_units }
+
+      subject { Estimator.new(order) }
+
+      context "#shipping rates" do
+        before(:each) do
+          shipping_method.zones.first.members.create(zoneable: order.ship_address.country)
+          allow_any_instance_of(ShippingMethod).to receive_message_chain(:calculator, :available?).and_return(true)
+          allow_any_instance_of(ShippingMethod).to receive_message_chain(:calculator, :compute).and_return(4.00)
+          allow_any_instance_of(ShippingMethod).to receive_message_chain(:calculator, :preferences).and_return({currency: currency})
+          allow_any_instance_of(ShippingMethod).to receive_message_chain(:calculator, :marked_for_destruction?)
+
+          allow(package).to receive_messages(shipping_methods: [shipping_method])
+        end
+
+        let(:currency) { "USD" }
+
+        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 calculator is not available for that order" do
+          before { allow_any_instance_of(ShippingMethod).to receive_message_chain(:calculator, :available?).and_return(false) }
+          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
+          shipping_methods = 3.times.map { create(:shipping_method) }
+          allow(shipping_methods[0]).to receive_message_chain(:calculator, :compute).and_return(5.00)
+          allow(shipping_methods[1]).to receive_message_chain(:calculator, :compute).and_return(3.00)
+          allow(shipping_methods[2]).to receive_message_chain(:calculator, :compute).and_return(4.00)
+
+          allow(subject).to receive(:shipping_methods).and_return(shipping_methods)
+
+          expect(subject.shipping_rates(package).map(&:cost)).to eq %w[3.00 4.00 5.00].map(&BigDecimal.method(:new))
+        end
+
+        context "general shipping methods" do
+          let(:shipping_methods) { 2.times.map { create(:shipping_method) } }
+
+          it "selects the most affordable shipping rate" do
+            allow(shipping_methods[0]).to receive_message_chain(:calculator, :compute).and_return(5.00)
+            allow(shipping_methods[1]).to receive_message_chain(:calculator, :compute).and_return(3.00)
+
+            allow(subject).to receive(:shipping_methods).and_return(shipping_methods)
+
+            expect(subject.shipping_rates(package).sort_by(&:cost).map(&:selected)).to eq [true, false]
+          end
+
+          it "selects the most affordable shipping rate and doesn't raise exception over nil cost" do
+            allow(shipping_methods[0]).to receive_message_chain(:calculator, :compute).and_return(1.00)
+            allow(shipping_methods[1]).to receive_message_chain(:calculator, :compute).and_return(nil)
+
+            allow(subject).to receive(:shipping_methods).and_return(shipping_methods)
+
+            subject.shipping_rates(package)
+          end
+        end
+
+        context "involves backend only shipping methods" do
+          let(:backend_method) { create(:shipping_method, display_on: "back_end") }
+          let(:generic_method) { create(:shipping_method) }
+
+          before do
+            allow(backend_method).to receive_message_chain(:calculator, :compute).and_return(0.00)
+            allow(generic_method).to receive_message_chain(:calculator, :compute).and_return(5.00)
+            allow(package).to receive(:shipping_methods).and_return([backend_method, generic_method])
+          end
+
+          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 #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 "includes tax adjustments if applicable" do
+          let!(:tax_rate) { create(:tax_rate, zone: order.tax_zone) }
+
+          before do
+            Spree::ShippingMethod.all.each do |sm|
+              sm.tax_category_id = tax_rate.tax_category_id
+              sm.save
+            end
+            package.shipping_methods.map(&:reload)
+          end
+
+
+          it "links the shipping rate and the tax rate" do
+            shipping_rates = subject.shipping_rates(package)
+            expect(shipping_rates.first.tax_rate).to eq(tax_rate)
+          end
+        end
+
+        context "VAT price calculation" do
+          let(:tax_category) { create :tax_category }
+          let!(:shipping_method) { create(:shipping_method, tax_category: tax_category) }
+
+          let(:default_zone) { create(:zone_with_country, default_tax: true) }
+          let!(:default_vat) do
+            create :tax_rate,
+                   included_in_price: true,
+                   zone: default_zone,
+                   amount: 0.2,
+                   tax_category: shipping_method.tax_category
+          end
+
+          context "when the order does not have a tax zone" do
+            before { allow(order).to receive(:tax_zone).and_return nil }
+            it_should_behave_like "shipping rate matches"
+          end
+
+          context "when the order's tax zone is the default zone" do
+            before { allow(order).to receive(:tax_zone).and_return(default_zone) }
+            it_should_behave_like "shipping rate matches"
+          end
+
+          context "when the order's tax zone is a non-VAT zone" do
+            let!(:zone_without_vat) { create(:zone_with_country) }
+            before { allow(order).to receive(:tax_zone).and_return(zone_without_vat) }
+
+            it 'deducts the default VAT from the cost' do
+              shipping_rates = subject.shipping_rates(package)
+              # deduct default vat: 4.00 / 1.2 = 3.33 (rounded)
+              expect(shipping_rates.first.cost).to eq(3.33)
+            end
+          end
+
+          context "when the order's tax zone is a zone with VAT outside the default zone" do
+            let(:other_vat_zone) { create(:zone_with_country) }
+            let!(:other_vat) do
+              create :tax_rate,
+                     included_in_price: true,
+                     zone: other_vat_zone,
+                     amount: 0.3,
+                     tax_category: shipping_method.tax_category
+            end
+
+            before { allow(order).to receive(:tax_zone).and_return(other_vat_zone) }
+
+            it 'deducts the default vat and applies the foreign vat to calculate the price' do
+              shipping_rates = subject.shipping_rates(package)
+              #
+              # deduct default vat: 4.00 / 1.2 = 3.33 (rounded)
+              # apply foreign vat: 3.33 * 1.3 = 4.33 (rounded)
+              expect(shipping_rates.first.cost).to eq(4.33)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    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 2
+          expect(units.first.line_item).to eq line_item_1
+          expect(units.first.variant).to eq line_item_1.variant
+          expect(units.first.quantity).to eq line_item_1.quantity
+
+          expect(units.second.line_item).to eq line_item_2
+          expect(units.second.variant).to eq line_item_2.variant
+          expect(units.second.quantity).to eq line_item_2.quantity
+        end
+
+        it "builds the inventory units as pending" do
+          expect(subject.units.map(&:pending).uniq).to eq [true]
+        end
+
+        it "sets the order_id on inventory units" do
+          expect(subject.units.map(&:order_id).uniq).to eq [order.id]
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    describe Package, type: :model do
+      let(:variant) { build(:variant, weight: 25.0) }
+      let(:stock_location) { build(:stock_location) }
+      let(:order) { build(:order) }
+
+      subject { Package.new(stock_location) }
+
+      def build_inventory_unit
+        build(:inventory_unit, variant: variant)
+      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
+
+      context "currency" do
+        let(:unit) { build_inventory_unit }
+        before { subject.add unit }
+
+        it "returns the currency based on the currency from the order" do
+          expect(subject.currency).to eql "USD"
+        end
+      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
+
+      # Contains regression test for #2804
+      it 'builds a list of shipping methods common to all categories' do
+        category1 = create(:shipping_category)
+        category2 = create(:shipping_category)
+        method1   = create(:shipping_method)
+        method2   = create(:shipping_method)
+        method1.shipping_categories = [category1, category2]
+        method2.shipping_categories = [category1]
+        variant1 = create(:product, shipping_category: category1).master
+        variant2 = create(:product, shipping_category: category2).master
+        contents = [ContentItem.new(build(:inventory_unit, variant_id: variant1.id)),
+                    ContentItem.new(build(:inventory_unit, variant_id: variant1.id)),
+                    ContentItem.new(build(:inventory_unit, variant_id: variant2.id))]
+
+        package = Package.new(stock_location, contents)
+        expect(package.shipping_methods).to eq([method1])
+      end
+
+      it 'builds an empty list of shipping methods when no categories' do
+        variant  = mock_model(Variant, shipping_category: 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)
+        subject.shipping_rates = [ Spree::ShippingRate.new(shipping_method: shipping_method, cost: 10.00, selected: true) ]
+
+        shipment = subject.to_shipment
+        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
+
+      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 unit.order
+          end
+        end
+
+        context "there is no inventory unit" do
+          it "returns nil" do
+            expect(subject.order).to eq nil
+          end
+        end
+      end
+
+      context "#volume" do
+        it "calculates the sum of the volume of all the items" do
+          contents = [ContentItem.new(build(:inventory_unit, variant: build(:variant))),
+                      ContentItem.new(build(:inventory_unit, variant: build(:variant))),
+                      ContentItem.new(build(:inventory_unit, variant: build(:variant))),
+                      ContentItem.new(build(:inventory_unit, variant: build(:variant)))]
+          package = Package.new(stock_location, contents)
+          expect(package.volume).to eq contents.sum(&:volume)
+        end
+      end
+
+      context "#dimension" do
+        it "calculates the sum of the dimension of all the items" do
+          contents = [ContentItem.new(build(:inventory_unit, variant: build(:variant))),
+                      ContentItem.new(build(:inventory_unit, variant: build(:variant))),
+                      ContentItem.new(build(:inventory_unit, variant: build(:variant))),
+                      ContentItem.new(build(:inventory_unit, variant: build(:variant)))]
+          package = Package.new(stock_location, contents)
+          expect(package.dimension).to eq contents.sum(&:dimension)
+        end
+      end
+    end
+  end
+end