solidus_core 1.1.0 → 1.1.1

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_manifest_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+module Spree
+  describe ShippingManifest, :type => :model do
+    let(:order) { Order.create! }
+    let(:variant) { create :variant }
+    let!(:shipment) { create(:shipment, state: 'pending', order: order) }
+    let(:manifest) { described_class.new(inventory_units: inventory_units) }
+
+    def build_unit(variant, attrs={})
+      attrs = {order: order, variant: variant, shipment: shipment}.merge(attrs)
+      attrs[:line_item] = attrs[:order].contents.add(attrs[:variant])
+      InventoryUnit.new(attrs)
+    end
+
+    subject{ manifest }
+
+    describe "#items" do
+      context 'empty' do
+        let(:inventory_units) { [] }
+        it "has correct item" do
+          expect(manifest.items.count).to eq 0
+        end
+      end
+
+      context 'single unit' do
+        let(:inventory_units) { [build_unit(variant)] }
+        it "has correct item" do
+          expect(manifest.items.count).to eq 1
+          expect(manifest.items[0]).to have_attributes(
+            variant: variant,
+            quantity: 1,
+            states: {"on_hand" => 1}
+          )
+        end
+      end
+
+      context 'two units of same variant' do
+        let(:inventory_units) { [build_unit(variant), build_unit(variant)] }
+        it "has correct item" do
+          expect(manifest.items.count).to eq 1
+          expect(manifest.items[0]).to have_attributes(
+            variant: variant,
+            quantity: 2,
+            states: {"on_hand" => 2}
+          )
+        end
+      end
+
+      context 'two units of different variants' do
+        let(:variant2){ create :variant }
+        let(:inventory_units) { [build_unit(variant), build_unit(variant2)] }
+        it "has correct item" do
+          expect(manifest.items.count).to eq 2
+          expect(manifest.items[0]).to have_attributes(
+            variant: variant,
+            quantity: 1,
+            states: {"on_hand" => 1}
+          )
+          expect(manifest.items[1]).to have_attributes(
+            variant: variant2,
+            quantity: 1,
+            states: {"on_hand" => 1}
+          )
+        end
+      end
+    end
+
+    describe "#for_order" do
+      let!(:order2) { Order.create! }
+      context 'single unit' do
+        let(:inventory_units) { [build_unit(variant)] }
+        it "has single ManifestItem in correct order" do
+          expect(manifest.for_order(order).items.count).to eq 1
+        end
+
+        it "has no ManifestItem in other order" do
+          expect(manifest.for_order(order2).items.count).to eq 0
+        end
+      end
+
+      context 'one units in each order' do
+        let(:inventory_units) { [build_unit(variant), build_unit(variant, order: order2)] }
+        it "has single ManifestItem in first order" do
+          expect(manifest.for_order(order).items.count).to eq 1
+        end
+
+        it "has single ManifestItem in second order" do
+          expect(manifest.for_order(order2).items.count).to eq 1
+        end
+      end
+    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