solidus_core 1.0.2 → 1.0.3

data/spec/models/spree/shipping_calculator_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+module Spree
+  describe ShippingCalculator, :type => :model do
+    let(:variant1) { build(:variant, :price => 10) }
+    let(:variant2) { build(:variant, :price => 20) }
+
+    let(:package) do
+      build(:stock_package, variants_contents: { variant1 => 2, variant2 => 1 })
+    end
+
+    subject { ShippingCalculator.new }
+
+    it 'computes with a shipment' do
+      shipment = mock_model(Spree::Shipment)
+      expect(subject).to receive(:compute_shipment).with(shipment)
+      subject.compute(shipment)
+    end
+
+    it 'computes with a package' do
+      expect(subject).to receive(:compute_package).with(package)
+      subject.compute(package)
+    end
+
+    it 'compute_shipment must be overridden' do
+      expect {
+        subject.compute_shipment(shipment)
+      }.to raise_error NameError
+    end
+
+    it 'compute_package must be overridden' do
+      expect {
+        subject.compute_package(package)
+      }.to raise_error NotImplementedError
+    end
+
+    it 'checks availability for a package' do
+      expect(subject.available?(package)).to be true
+    end
+
+    it 'calculates totals for content_items' do
+      expect(subject.send(:total, package.contents)).to eq 40.00
+    end
+  end
+end

data/spec/models/spree/shipping_method_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+class DummyShippingCalculator < Spree::ShippingCalculator
+end
+
+describe Spree::ShippingMethod, :type => :model do
+  let(:shipping_method){ create(:shipping_method) }
+
+  context 'calculators' do
+    it "Should reject calculators that don't inherit from Spree::ShippingCalculator" do
+      allow(Spree::ShippingMethod).to receive_message_chain(:spree_calculators, :shipping_methods).and_return([
+        Spree::Calculator::Shipping::FlatPercentItemTotal,
+        Spree::Calculator::Shipping::PriceSack,
+        Spree::Calculator::DefaultTax,
+        DummyShippingCalculator # included as regression test for https://github.com/spree/spree/issues/3109
+      ])
+
+      expect(Spree::ShippingMethod.calculators).to eq([Spree::Calculator::Shipping::FlatPercentItemTotal, Spree::Calculator::Shipping::PriceSack, DummyShippingCalculator ])
+      expect(Spree::ShippingMethod.calculators).not_to eq([Spree::Calculator::DefaultTax])
+    end
+  end
+
+  # Regression test for #4492
+  context "#shipments" do
+    let!(:shipping_method) { create(:shipping_method) }
+    let!(:shipment) do
+      shipment = create(:shipment)
+      shipment.shipping_rates.create!(:shipping_method => shipping_method)
+      shipment
+    end
+
+    it "can gather all the related shipments" do
+      expect(shipping_method.shipments).to include(shipment)
+    end
+  end
+
+  context "validations" do
+    before { subject.valid? }
+
+    it "validates presence of name" do
+      expect(subject.error_on(:name).size).to eq(1)
+    end
+
+    context "shipping category" do
+      it "validates presence of at least one" do
+        expect(subject.error_on(:base).size).to eq(1)
+      end
+
+      context "one associated" do
+        before { subject.shipping_categories.push create(:shipping_category) }
+        it { expect(subject.error_on(:base).size).to eq(0) }
+      end
+    end
+  end
+
+  context 'factory' do
+    it "should set calculable correctly" do
+      expect(shipping_method.calculator.calculable).to eq(shipping_method)
+    end
+  end
+
+  context "generating tracking URLs" do
+    context "shipping method has a tracking URL mask on file" do
+      let(:tracking_url) { "https://track-o-matic.com/:tracking" }
+      before { allow(subject).to receive(:tracking_url) { tracking_url } }
+
+      context 'tracking number has spaces' do
+        let(:tracking_numbers) { ["1234 5678 9012 3456", "a bcdef"] }
+        let(:expectations) { %w[https://track-o-matic.com/1234%205678%209012%203456 https://track-o-matic.com/a%20bcdef] }
+
+        it "should return a single URL with '%20' in lieu of spaces" do
+          tracking_numbers.each_with_index do |num, i|
+            expect(subject.build_tracking_url(num)).to eq(expectations[i])
+          end
+        end
+      end
+    end
+  end
+
+  # Regression test for #4320
+  context "soft deletion" do
+    let(:shipping_method) { create(:shipping_method) }
+    it "soft-deletes when destroy is called" do
+      shipping_method.destroy
+      expect(shipping_method.deleted_at).not_to be_blank
+    end
+  end
+end

data/spec/models/spree/shipping_rate_spec.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Spree::ShippingRate, :type => :model do
+  let(:shipment) { create(:shipment) }
+  let(:shipping_method) { create(:shipping_method) }
+  let(:shipping_rate) { Spree::ShippingRate.new(:shipment => shipment,
+                                                :shipping_method => shipping_method,
+                                                :cost => 10) }
+
+  context "#display_price" do
+    context "when tax included in price" do
+      context "when the tax rate is from the default zone" do
+        before { shipment.order.update_attributes!(ship_address_id: nil) }
+        let!(:zone) { create(:zone, :default_tax => true) }
+        let(:tax_rate) do
+          create(:tax_rate,
+            :name => "VAT",
+            :amount => 0.1,
+            :included_in_price => true,
+            :zone => zone)
+        end
+
+        before { shipping_rate.tax_rate = tax_rate }
+
+        it "shows correct tax amount" do
+          expect(shipping_rate.display_price.to_s).to eq("$10.00 (incl. $0.91 #{tax_rate.name})")
+        end
+
+        context "when cost is zero" do
+          before do
+            shipping_rate.cost = 0
+          end
+
+          it "shows no tax amount" do
+            expect(shipping_rate.display_price.to_s).to eq("$0.00")
+          end
+        end
+      end
+
+      context "when the tax rate is from a non-default zone" do
+        let!(:default_zone) { create(:zone, :default_tax => true) }
+        let!(:non_default_zone) { create(:zone, :default_tax => false) }
+        let(:tax_rate) do
+          create(:tax_rate,
+            :name => "VAT",
+            :amount => 0.1,
+            :included_in_price => true,
+            :zone => non_default_zone)
+        end
+        before { shipping_rate.tax_rate = tax_rate }
+
+        it "shows correct tax amount" do
+          expect(shipping_rate.display_price.to_s).to eq("$10.00 (excl. $0.91 #{tax_rate.name})")
+        end
+
+        context "when cost is zero" do
+          before do
+            shipping_rate.cost = 0
+          end
+
+          it "shows no tax amount" do
+            expect(shipping_rate.display_price.to_s).to eq("$0.00")
+          end
+        end
+      end
+    end
+
+    context "when tax is additional to price" do
+      let(:tax_rate) { create(:tax_rate, :name => "Sales Tax", :amount => 0.1) }
+      before { shipping_rate.tax_rate = tax_rate }
+
+      it "shows correct tax amount" do
+        expect(shipping_rate.display_price.to_s).to eq("$10.00 (+ $1.00 #{tax_rate.name})")
+      end
+
+      context "when cost is zero" do
+        before do
+          shipping_rate.cost = 0
+        end
+
+        it "shows no tax amount" do
+          expect(shipping_rate.display_price.to_s).to eq("$0.00")
+        end
+      end
+    end
+
+    context "when the currency is JPY" do
+      let(:shipping_rate) { shipping_rate = Spree::ShippingRate.new(:cost => 205)
+                            allow(shipping_rate).to receive_messages(:currency => "JPY")
+                            shipping_rate }
+
+      it "displays the price in yen" do
+        expect(shipping_rate.display_price.to_s).to eq("¥205")
+      end
+    end
+  end
+
+  # Regression test for #3829
+  context "#shipping_method" do
+    it "can be retrieved" do
+      expect(shipping_rate.shipping_method.reload).to eq(shipping_method)
+    end
+
+    it "can be retrieved even when deleted" do
+      shipping_method.update_column(:deleted_at, Time.now)
+      shipping_rate.save
+      shipping_rate.reload
+      expect(shipping_rate.shipping_method).to eq(shipping_method)
+    end
+  end
+
+  context "#tax_rate" do
+    let!(:tax_rate) { create(:tax_rate) }
+
+    before do
+      shipping_rate.tax_rate = tax_rate
+    end
+
+    it "can be retrieved" do
+      expect(shipping_rate.tax_rate.reload).to eq(tax_rate)
+    end
+
+    it "can be retrieved even when deleted" do
+      tax_rate.update_column(:deleted_at, Time.now)
+      shipping_rate.save
+      shipping_rate.reload
+      expect(shipping_rate.tax_rate).to eq(tax_rate)
+    end
+  end
+
+  context "#shipping_method_code" do
+    before do
+      shipping_method.code = "THE_CODE"
+    end
+
+    it 'should be shipping_method.code' do
+      expect(shipping_rate.shipping_method_code).to eq("THE_CODE")
+    end
+  end
+end

data/spec/models/spree/state_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Spree::State, :type => :model do
+  it "can find a state by name or abbr" do
+    state = create(:state, :name => "California", :abbr => "CA")
+    expect(Spree::State.find_all_by_name_or_abbr("California")).to include(state)
+    expect(Spree::State.find_all_by_name_or_abbr("CA")).to include(state)
+  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/availability_validator_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    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}"
+          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
+          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 all stock locations" do
+          let(:line_item)         { order.line_items.first }
+
+          before do
+            variant_ids = order.line_items.map(&:variant_id)
+            Spree::StockItem.where(variant_id: variant_ids).update_all(count_on_hand: 10, backorderable: false)
+          end
+
+          include_examples "passes validation"
+        end
+
+        context "doesn't have stock in a particular stock location" do
+          let(:variant)           { create(:variant) }
+          let(:line_item)         { order.line_items.find_by(variant_id: variant.id) }
+          let!(:stock_location_1) { create(:stock_location, name: "Test Warehouse", active: false) }
+
+          before do
+            order.contents.add(variant, 1, stock_location_quantities: { stock_location_1.id => 1})
+            order.contents.advance
+            stock_location_1.stock_items.update_all(count_on_hand: 0, backorderable: false)
+          end
+
+          include_examples "fails validation"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    describe Coordinator, :type => :model do
+      let!(:order) { create(:order_with_line_items, line_items_count: 2) }
+
+      subject { Coordinator.new(order) }
+
+      context "packages" do
+        it "builds, prioritizes and estimates" do
+          expect(subject).to receive(:build_location_configured_packages).ordered
+          expect(subject).to receive(:build_packages).ordered
+          expect(subject).to receive(:prioritize_packages).ordered
+          expect(subject).to receive(:estimate_packages).ordered
+          subject.packages
+        end
+      end
+
+      describe "#shipments" do
+        let(:packages) { [build(:stock_package_fulfilled), build(:stock_package_fulfilled)] }
+
+        before { allow(subject).to receive(:packages).and_return(packages) }
+
+        it "turns packages into shipments" do
+          shipments = subject.shipments
+          expect(shipments.count).to eq packages.count
+          shipments.each { |shipment| expect(shipment).to be_a Shipment }
+        end
+
+        it "puts the order's ship address on the shipments" do
+          shipments = subject.shipments
+          shipments.each { |shipment| expect(shipment.address).to eq order.ship_address }
+        end
+      end
+
+      context "build packages" do
+        it "builds a package for all active stock locations" do
+          subject.packages.count == StockLocation.count
+        end
+
+        context "missing stock items in active stock location" do
+          let!(:another_location) { create(:stock_location, propagate_all_variants: false) }
+
+          it "builds packages only for valid active stock locations" do
+            expect(subject.build_packages.count).to eq(StockLocation.count - 1)
+          end
+        end
+      end
+
+      # regression spec
+      context "when there is one unit that has stock in a stock location that a non-tracked unit has no stock item in" do
+        let!(:stock_location_1) { create(:stock_location, propagate_all_variants: false, active: true) }
+        let!(:stock_location_2) { create(:stock_location, propagate_all_variants: false, active: true) }
+
+        let!(:variant_1) do
+          create(:variant, track_inventory: true).tap do |variant|
+            variant.stock_items.destroy_all
+            stock_item = variant.stock_items.create!(stock_location: stock_location_1)
+            stock_item.set_count_on_hand(10)
+          end
+        end
+        let!(:variant_2) do
+          create(:variant, track_inventory: false).tap do |variant|
+            variant.stock_items.destroy_all
+            stock_item = variant.stock_items.create!(stock_location: stock_location_2)
+            stock_item.set_count_on_hand(0)
+          end
+        end
+
+        let!(:order) { create(:order, line_items: [create(:line_item, variant: variant_1), create(:line_item, variant: variant_2)]) }
+
+        it "splits the inventory units to stock locations that they have stock items for" do
+          packages = subject.packages
+
+          expect(subject.packages.size).to eq 2
+
+          location_1_package = packages.detect { |p| p.stock_location == stock_location_1 }
+          location_2_package = packages.detect { |p| p.stock_location == stock_location_2 }
+
+          expect(location_1_package).to be_present
+          expect(location_2_package).to be_present
+
+          expect(location_1_package.contents.map(&:inventory_unit).map(&:variant)).to eq [variant_1]
+          expect(location_2_package.contents.map(&:inventory_unit).map(&:variant)).to eq [variant_2]
+        end
+      end
+
+      context "build location configured packages" do
+        context "there are configured stock locations" do
+          let(:stock_location) { order.variants.first.stock_locations.first }
+          let!(:stock_location_2) { create(:stock_location) }
+
+          before do
+            line_item_1 = order.line_items.first
+            line_item_2 = order.line_items.last
+            order.order_stock_locations.create(stock_location_id: stock_location.id, quantity: line_item_1.quantity, variant_id: line_item_1.variant_id)
+            order.order_stock_locations.create(stock_location_id: stock_location_2.id, quantity: line_item_2.quantity, variant_id: line_item_2.variant_id)
+          end
+
+          it "builds a package for each associated stock location" do
+            packages = subject.build_location_configured_packages
+            expect(packages.count).to eq(2)
+            expect(packages.map(&:stock_location)).to eq([stock_location, stock_location_2])
+          end
+        end
+        context "there are no configured stock locations" do
+          it "doesn't build any packages" do
+            packages = subject.build_location_configured_packages
+            expect(packages.count).to eq(0)
+          end
+        end
+      end
+    end
+  end
+end