spree_core 3.0.9 → 3.2.0

data/spec/models/spree/state_spec.rb

@@ -1,8 +1,19 @@
 require 'spec_helper'
 
-describe Spree::State, :type => :model do
+describe Spree::State, type: :model do
+  describe 'Associations' do
+    it { is_expected.to have_many(:addresses).dependent(:restrict_with_error) }
+  end
+
+  describe 'validations' do
+    it { is_expected.to validate_presence_of(:name) }
+    it { is_expected.to validate_presence_of(:country) }
+    it { is_expected.to validate_uniqueness_of(:name).scoped_to(:country_id).case_insensitive }
+    it { is_expected.to validate_uniqueness_of(:abbr).scoped_to(:country_id).case_insensitive }
+  end
+
   it "can find a state by name or abbr" do
-    state = create(:state, :name => "California", :abbr => "CA")
+    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

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module Stock
-    describe AvailabilityValidator, :type => :model do
+    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 }

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

@@ -6,6 +6,15 @@ module Spree
       let(:variant) { build(:variant, weight: 25.0) }
       subject { ContentItem.new(build(:inventory_unit, variant: variant)) }
 
+      describe 'Delegations' do
+        it { is_expected.to delegate_method(:line_item).to(:inventory_unit) }
+        it { is_expected.to delegate_method(:variant).to(:inventory_unit) }
+        it { is_expected.to delegate_method(:dimension).to(:variant).with_prefix }
+        it { is_expected.to delegate_method(:price).to(:variant) }
+        it { is_expected.to delegate_method(:volume).to(:variant).with_prefix }
+        it { is_expected.to delegate_method(:weight).to(:variant).with_prefix }
+      end
+
       context "#volume" do
         it "calculate the total volume of the variant" do
           expect(subject.volume).to eq variant.volume * subject.quantity

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

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 module Spree
   module Stock
-    describe Coordinator, :type => :model do
-      let!(:order) { create(:order_with_line_items) }
+    describe Coordinator, type: :model do
+      let(:order) { create(:order_with_line_items) }
 
       subject { Coordinator.new(order) }
 
@@ -34,8 +34,18 @@ module Spree
       end
 
       context "build packages" do
+        let!(:stock_location1) { create(:stock_location, backorderable_default: false) }
+        let!(:stock_location2) { create(:stock_location, backorderable_default: false) }
+        let!(:product) { create(:product) }
+
+        let!(:order) do
+          product.stock_items.map { |stock_item| stock_item.adjust_count_on_hand(1) }
+          line_item = create(:line_item, product: product, quantity: 2)
+          line_item.order
+        end
+
         it "builds a package for every stock location" do
-          subject.packages.count == StockLocation.count
+          expect(subject.build_packages.count).to eq(StockLocation.count)
         end
 
         context "missing stock items in stock location" do

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module Stock
-    describe Differentiator, :type => :model do
+    describe Differentiator, type: :model do
       let(:variant1) { mock_model(Variant) }
       let(:variant2) { mock_model(Variant) }
 

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module Stock
-    describe Estimator, :type => :model do
+    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) }
@@ -12,13 +12,13 @@ module Spree
 
       context "#shipping rates" do
         before(:each) do
-          shipping_method.zones.first.members.create(:zoneable => order.ship_address.country)
+          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, :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])
+          allow(package).to receive_messages(shipping_methods: [shipping_method])
         end
 
         let(:currency) { "USD" }
@@ -70,14 +70,6 @@ module Spree
           it_should_behave_like "shipping rate doesn't match"
         end
 
-        context "when the shipping method's calculator raises an exception" do
-          before do
-            allow_any_instance_of(ShippingMethod).to receive_message_chain(:calculator, :available?).and_raise(Exception, "Something went wrong!")
-            expect(subject).to receive(:log_calculator_exception)
-          end
-          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)
@@ -148,6 +140,62 @@ module Spree
             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

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module Stock
-    describe InventoryUnitBuilder, :type => :model do
+    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]) }

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module Stock
-    describe Package, :type => :model do
+    describe Package, type: :model do
       let(:variant) { build(:variant, weight: 25.0) }
       let(:stock_location) { build(:stock_location) }
       let(:order) { build(:order) }
@@ -64,13 +64,11 @@ module Spree
         method2   = create(:shipping_method)
         method1.shipping_categories = [category1, category2]
         method2.shipping_categories = [category1]
-        variant1 = mock_model(Variant, shipping_category: category1)
-        variant2 = mock_model(Variant, shipping_category: category2)
-        variant3 = mock_model(Variant, shipping_category: nil)
-        contents = [ContentItem.new(build(:inventory_unit, variant: variant1)),
-                    ContentItem.new(build(:inventory_unit, variant: variant1)),
-                    ContentItem.new(build(:inventory_unit, variant: variant2)),
-                    ContentItem.new(build(:inventory_unit, variant: variant3))]
+        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])
@@ -106,16 +104,6 @@ module Spree
         expect(shipment.shipping_method).to eq shipping_method
       end
 
-      it 'does not add an inventory unit to a package twice' do
-        # since inventory units currently don't have a quantity
-        unit = build_inventory_unit
-        subject.add unit
-        subject.add unit
-        expect(subject.quantity).to eq 1
-        expect(subject.contents.first.inventory_unit).to eq unit
-        expect(subject.contents.first.quantity).to eq 1
-      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)

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module Stock
-    describe Packer, :type => :model do
+    describe Packer, type: :model do
       let(:inventory_units) { [InventoryUnit.new(variant: create(:variant))] }
       let(:stock_location) { create(:stock_location) }
 

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module Stock
-    describe Prioritizer, :type => :model do
+    describe Prioritizer, type: :model do
       let(:order) { mock_model(Order) }
       let(:stock_location) { build(:stock_location) }
       let(:variant) { build(:variant) }
@@ -30,7 +30,7 @@ module Spree
         end
 
         packages = [package1]
-        prioritizer = Prioritizer.new(inventory_units, packages)
+        prioritizer = Prioritizer.new(packages)
         packages = prioritizer.prioritized_packages
         expect(packages.size).to eq 1
       end
@@ -47,7 +47,7 @@ module Spree
         end
 
         packages = [package1, package2]
-        prioritizer = Prioritizer.new(inventory_units, packages)
+        prioritizer = Prioritizer.new(packages)
         packages = prioritizer.prioritized_packages
         expect(packages.size).to eq 1
       end
@@ -61,7 +61,7 @@ module Spree
         end
 
         packages = [package1, package2]
-        prioritizer = Prioritizer.new(inventory_units, packages)
+        prioritizer = Prioritizer.new(packages)
         packages = prioritizer.prioritized_packages
         expect(packages.size).to eq 2
       end
@@ -77,7 +77,7 @@ module Spree
         end
 
         packages = [package1, package2]
-        prioritizer = Prioritizer.new(inventory_units, packages)
+        prioritizer = Prioritizer.new(packages)
         packages = prioritizer.prioritized_packages
         expect(packages.count).to eq 2
         expect(packages[0].quantity).to eq 2
@@ -95,7 +95,7 @@ module Spree
         end
 
         packages = [package1, package2]
-        prioritizer = Prioritizer.new(inventory_units, packages)
+        prioritizer = Prioritizer.new(packages)
         packages = prioritizer.prioritized_packages
 
         expect(packages[0].quantity(:backordered)).to eq 3
@@ -113,7 +113,7 @@ module Spree
         end
 
         packages = [package1, package2]
-        prioritizer = Prioritizer.new(inventory_units, packages)
+        prioritizer = Prioritizer.new(packages)
         packages = prioritizer.prioritized_packages
         expect(packages[0]).to eq package2
         expect(packages[1]).to be_nil

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

@@ -19,45 +19,60 @@ module Spree
       subject { described_class.new(stock_item.variant) }
 
       specify { expect(subject.stock_items).to eq([stock_item]) }
+      specify { expect(subject.variant).to eq(stock_item.variant) }
 
       context 'with a single stock location/item' do
         it 'total_on_hand should match stock_item' do
           expect(subject.total_on_hand).to eq(stock_item.count_on_hand)
         end
 
-        context 'when track_inventory_levels is false' do
-          before { configure_spree_preferences { |config| config.track_inventory_levels = false } }
+        context 'when variant is available' do
+          before(:each) do
+            allow(subject.variant).to receive(:available?) { true }
+          end
 
-          specify { expect(subject.total_on_hand).to eq(Float::INFINITY) }
+          context 'when track_inventory_levels is false' do
+            before { configure_spree_preferences { |config| config.track_inventory_levels = false } }
 
-          it_should_behave_like 'unlimited supply'
-        end
+            specify { expect(subject.total_on_hand).to eq(Float::INFINITY) }
 
-        context 'when variant inventory tracking is off' do
-          before { stock_item.variant.track_inventory = false }
+            it_should_behave_like 'unlimited supply'
+          end
 
-          specify { expect(subject.total_on_hand).to eq(Float::INFINITY) }
+          context 'when variant inventory tracking is off' do
+            before { stock_item.variant.track_inventory = false }
 
-          it_should_behave_like 'unlimited supply'
-        end
+            specify { expect(subject.total_on_hand).to eq(Float::INFINITY) }
+
+            it_should_behave_like 'unlimited supply'
+          end
 
-        context 'when stock item allows backordering' do
+          context 'when stock item allows backordering' do
 
-          specify { expect(subject.backorderable?).to be true }
+            specify { expect(subject.backorderable?).to be true }
 
-          it_should_behave_like 'unlimited supply'
-        end
+            it_should_behave_like 'unlimited supply'
+          end
 
-        context 'when stock item prevents backordering' do
-          before { stock_item.update_attributes(backorderable: false) }
+          context 'when stock item prevents backordering' do
+            before { stock_item.update_attributes(backorderable: false) }
 
-          specify { expect(subject.backorderable?).to be false }
+            specify { expect(subject.backorderable?).to be false }
+
+            it 'can_supply? only upto total_on_hand' do
+              expect(subject.can_supply?(1)).to be true
+              expect(subject.can_supply?(10)).to be true
+              expect(subject.can_supply?(11)).to be false
+            end
+          end
+        end
 
-          it 'can_supply? only upto total_on_hand' do
-            expect(subject.can_supply?(1)).to be true
-            expect(subject.can_supply?(10)).to be true
-            expect(subject.can_supply?(11)).to be false
+        context 'when variant is not available' do
+          before(:each) do
+            allow(subject.variant).to receive(:available?) { false }
           end
+
+          it { expect(subject.can_supply?).to be false }
         end
       end
 
@@ -74,23 +89,37 @@ module Spree
           expect(subject.total_on_hand).to eq(15)
         end
 
-        context 'when any stock item allows backordering' do
-          specify { expect(subject.backorderable?).to be true }
+        context 'when variant is available' do
+          before(:each) do
+            allow(subject.variant).to receive(:available?) { true }
+          end
 
-          it_should_behave_like 'unlimited supply'
-        end
+          context 'when any stock item allows backordering' do
+            specify { expect(subject.backorderable?).to be true }
+
+            it_should_behave_like 'unlimited supply'
+          end
 
-        context 'when all stock items prevent backordering' do
-          before { stock_item.update_attributes(backorderable: false) }
+          context 'when all stock items prevent backordering' do
+            before { stock_item.update_attributes(backorderable: false) }
 
-          specify { expect(subject.backorderable?).to be false }
+            specify { expect(subject.backorderable?).to be false }
 
-          it 'can_supply? upto total_on_hand' do
-            expect(subject.can_supply?(1)).to be true
-            expect(subject.can_supply?(15)).to be true
-            expect(subject.can_supply?(16)).to be false
+            it 'can_supply? upto total_on_hand' do
+              expect(subject.can_supply?(1)).to be true
+              expect(subject.can_supply?(15)).to be true
+              expect(subject.can_supply?(16)).to be false
+            end
           end
         end
+
+        context 'when variant is not available' do
+          before(:each) do
+            allow(subject.variant).to receive(:available?) { false }
+          end
+
+          it { expect(subject.can_supply?).to be false }
+        end
       end
     end
   end

data/spec/models/spree/stock/splitter/backordered_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module Spree
   module Stock
     module Splitter
-      describe Backordered, :type => :model do
+      describe Backordered, type: :model do
         let(:variant) { build(:variant) }
 
         let(:packer) { build(:stock_packer) }

data/spec/models/spree/stock/splitter/base_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module Spree
   module Stock
     module Splitter
-      describe Base, :type => :model do
+      describe Base, type: :model do
         let(:packer) { build(:stock_packer) }
 
         it 'continues to splitter chain' do

data/spec/models/spree/stock/splitter/shipping_category_spec.rb

@@ -3,10 +3,10 @@ require 'spec_helper'
 module Spree
   module Stock
     module Splitter
-      describe ShippingCategory, :type => :model do
+      describe ShippingCategory, type: :model do
 
-        let(:variant1) { build(:variant) }
-        let(:variant2) { build(:variant) }
+        let(:variant1) { create(:variant) }
+        let(:variant2) { create(:variant) }
         let(:shipping_category_1) { create(:shipping_category, name: 'A') }
         let(:shipping_category_2) { create(:shipping_category, name: 'B') }
 

data/spec/models/spree/stock_item_spec.rb

@@ -1,10 +1,12 @@
 require 'spec_helper'
 
-describe Spree::StockItem, :type => :model do
+describe Spree::StockItem, type: :model do
   let(:stock_location) { create(:stock_location_with_items) }
 
   subject { stock_location.stock_items.order(:id).first }
 
+  it { is_expected.to delegate_method(:product).to(:variant) }
+
   it 'maintains the count on hand for a variant' do
     expect(subject.count_on_hand).to eq 10
   end
@@ -73,7 +75,7 @@ describe Spree::StockItem, :type => :model do
       let(:inventory_unit_2) { double('InventoryUnit2') }
 
       before do
-        allow(subject).to receive_messages(:backordered_inventory_units => [inventory_unit, inventory_unit_2])
+        allow(subject).to receive_messages(backordered_inventory_units: [inventory_unit, inventory_unit_2])
         subject.update_column(:count_on_hand, -2)
       end
 
@@ -94,7 +96,7 @@ describe Spree::StockItem, :type => :model do
       end
 
       context "adds new items" do
-        before { allow(subject).to receive_messages(:backordered_inventory_units => [inventory_unit, inventory_unit_2]) }
+        before { allow(subject).to receive_messages(backordered_inventory_units: [inventory_unit, inventory_unit_2]) }
 
         it "fills existing backorders" do
           expect(inventory_unit).to receive(:fill_backorder)
@@ -132,7 +134,7 @@ describe Spree::StockItem, :type => :model do
       end
 
       context "adds new items" do
-        before { allow(subject).to receive_messages(:backordered_inventory_units => [inventory_unit, inventory_unit_2]) }
+        before { allow(subject).to receive_messages(backordered_inventory_units: [inventory_unit, inventory_unit_2]) }
 
         it "fills existing backorders" do
           expect(inventory_unit).to receive(:fill_backorder)
@@ -167,7 +169,7 @@ describe Spree::StockItem, :type => :model do
 
       expect {
         stock_location.stock_items.create!(variant: subject.variant)
-      }.to raise_error
+      }.to raise_error(StandardError)
     end
   end
 
@@ -224,9 +226,11 @@ describe Spree::StockItem, :type => :model do
 
   describe "#after_touch" do
     it "touches its variant" do
-      expect do
-        subject.touch
-      end.to change { subject.variant.updated_at }
+      Timecop.scale(1000) do
+        expect do
+          subject.touch
+        end.to change { subject.variant.updated_at }
+      end
     end
   end
 
@@ -407,4 +411,22 @@ describe Spree::StockItem, :type => :model do
       end
     end
   end
+
+  describe 'scopes' do
+    context '.with_active_stock_location' do
+      let(:stock_items_with_active_location) { Spree::StockItem.with_active_stock_location }
+
+      context 'when stock location is active' do
+        before { stock_location.update_column(:active, true) }
+
+        it { expect(stock_items_with_active_location).to include(subject) }
+      end
+
+      context 'when stock location is inactive' do
+        before { stock_location.update_column(:active, false) }
+
+        it { expect(stock_items_with_active_location).to_not include(subject) }
+      end
+    end
+  end
 end

data/spec/models/spree/stock_location_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe StockLocation, :type => :model do
+  describe StockLocation, type: :model do
     subject { create(:stock_location_with_items, backorderable_default: true) }
     let(:stock_item) { subject.stock_items.order(:id).first }
     let(:variant) { stock_item.variant }
@@ -132,14 +132,14 @@ module Spree
     end
 
     it 'can be deactivated' do
-      create(:stock_location, :active => true)
-      create(:stock_location, :active => false)
+      create(:stock_location, active: true)
+      create(:stock_location, active: false)
       expect(Spree::StockLocation.active.count).to eq 1
     end
 
     it 'ensures only one stock location is default at a time' do
-      first = create(:stock_location, :active => true, :default => true)
-      second = create(:stock_location, :active => true, :default => true)
+      first = create(:stock_location, active: true, default: true)
+      second = create(:stock_location, active: true, default: true)
 
       expect(first.reload.default).to eq false
       expect(second.reload.default).to eq true