spree_core 3.0.5 → 3.0.6

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
+    end
+
+    it 'compute_package must be overridden' do
+      expect {
+        subject.compute_package(package)
+      }.to raise_error
+    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_category_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Spree::ShippingCategory, :type => :model do
+
+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,141 @@
+# 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
+        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,18 @@
+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
+
+  describe 'whitelisted_ransackable_attributes' do
+    it { expect(Spree::State.whitelisted_ransackable_attributes).to eq(%w(abbr)) }
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    describe AvailabilityValidator, :type => :model do
+      let!(:line_item) { double(quantity: 5, variant_id: 1, variant: double.as_null_object, errors: double('errors'), inventory_units: []) }
+
+      subject { described_class.new }
+
+      it 'should be valid when supply is sufficient' do
+        allow_any_instance_of(Stock::Quantifier).to receive_messages(can_supply?: true)
+        expect(line_item).not_to receive(:errors)
+        subject.validate(line_item)
+      end
+
+      it 'should be invalid when supply is insufficent' do
+        allow_any_instance_of(Stock::Quantifier).to receive_messages(can_supply?: false)
+        expect(line_item.errors).to receive(:[]).with(:quantity).and_return []
+        subject.validate(line_item)
+      end
+
+      it 'should consider existing inventory_units sufficient' do
+        allow_any_instance_of(Stock::Quantifier).to receive_messages(can_supply?: false)
+        expect(line_item).not_to receive(:errors)
+        allow(line_item).to receive_messages(inventory_units: [double] * 5)
+        subject.validate(line_item)
+      end
+
+      it 'should be valid when the quantity is zero' do
+        expect(line_item).to receive(:quantity).and_return(0)
+        expect(line_item.errors).to_not receive(:[]).with(:quantity)
+        subject.validate(line_item)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    describe ContentItem, type: :model do
+      let(:variant) { build(:variant, weight: 25.0) }
+      subject { ContentItem.new(build(:inventory_unit, variant: variant)) }
+
+      context "#volume" do
+        it "calculate the total volume of the variant" do
+          expect(subject.volume).to eq variant.volume * subject.quantity
+        end
+      end
+
+      context "#dimension" do
+        it "calculate the total dimension of the variant" do
+          expect(subject.dimension).to eq variant.dimension * subject.quantity
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+module Spree
+  module Stock
+    describe Coordinator, :type => :model do
+      let!(:order) { create(:order_with_line_items) }
+
+      subject { Coordinator.new(order) }
+
+      context "packages" do
+        it "builds, prioritizes and estimates" do
+          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 every stock location" do
+          subject.packages.count == StockLocation.count
+        end
+
+        context "missing stock items in stock location" do
+          let!(:another_location) { create(:stock_location, propagate_all_variants: false) }
+
+          it "builds packages only for valid stock locations" do
+            expect(subject.build_packages.count).to eq(StockLocation.count - 1)
+          end
+        end
+      end
+    end
+  end
+end

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