spree_core 3.0.10 → 3.1.0.rc1

data/spec/models/spree/return_authorization_reason_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Spree::ReturnAuthorizationReason do
+  describe 'Associations' do
+    it { is_expected.to have_many(:return_authorizations).dependent(:restrict_with_error) }
+  end
+end

data/spec/models/spree/return_authorization_spec.rb

@@ -84,28 +84,8 @@ describe Spree::ReturnAuthorization, :type => :model do
     end
   end
 
-  describe ".before_create" do
-    describe "#generate_number" do
-      context "number is assigned" do
-        let(:return_authorization) { Spree::ReturnAuthorization.new(number: '123') }
-
-        it "should return the assigned number" do
-          return_authorization.save
-          expect(return_authorization.number).to eq('123')
-        end
-      end
-
-      context "number is not assigned" do
-        let(:return_authorization) { Spree::ReturnAuthorization.new(number: nil) }
-
-        before { allow(return_authorization).to receive_messages valid?: true }
-
-        it "should assign number with random RA number" do
-          return_authorization.save
-          expect(return_authorization.number).to match(/RA\d{9}/)
-        end
-      end
-    end
+  describe 'whitelisted_ransackable_attributes' do
+    it { expect(Spree::ReturnAuthorization.whitelisted_ransackable_attributes).to eq(%w(memo number state)) }
   end
 
   context "#currency" do

data/spec/models/spree/return_item_spec.rb

@@ -18,7 +18,7 @@ describe Spree::ReturnItem, :type => :model do
   end
 
   describe '#receive!' do
-    let(:now)            { Time.now }
+    let(:now)            { Time.current }
     let(:inventory_unit) { create(:inventory_unit, state: 'shipped') }
     let(:return_item)    { create(:return_item, inventory_unit: inventory_unit) }
 
@@ -679,4 +679,53 @@ describe Spree::ReturnItem, :type => :model do
       expect(return_item.total).to eq 20
     end
   end
+
+  describe '#process_inventory_unit!' do
+    let(:inventory_unit) { create(:inventory_unit, state: 'shipped') }
+    let(:return_item) { create(:return_item, inventory_unit: inventory_unit, reception_status: 'awaiting') }
+    let!(:stock_item) { inventory_unit.find_stock_item }
+    before { return_item.update_attributes!(reception_status: 'awaiting') }
+
+    subject { return_item.send(:process_inventory_unit!) }
+
+    it { expect { subject }.to change { inventory_unit.state }.to('returned').from('shipped') }
+
+    context 'stock should restock' do
+      let(:stock_movement_attributes) do
+        {
+          stock_item_id: stock_item.id,
+          quantity: 1,
+          originator: return_item.return_authorization
+        }
+      end
+
+      it { expect(subject).to eq(Spree::StockMovement.find_by(stock_movement_attributes)) }
+    end
+
+    context 'stock should not restock' do
+      context 'return_item is not resellable' do
+        before { return_item.resellable = false }
+        it { expect(subject).to be_nil }
+        it { expect { subject }.to_not change { stock_item.reload.count_on_hand } }
+      end
+
+      context 'variant should not track inventory' do
+        before { return_item.variant.track_inventory = false }
+        it { expect(subject).to be_nil }
+        it { expect { subject }.to_not change { stock_item.reload.count_on_hand } }
+      end
+
+      context 'stock_item not present' do
+        before { stock_item.destroy }
+        it { expect(subject).to be_nil }
+        it { expect { subject }.to_not change { stock_item.reload.count_on_hand } }
+      end
+
+      context 'when restock inventory preference false' do
+        before { Spree::Config[:restock_inventory] = false }
+        it { expect(subject).to be_nil }
+        it { expect { subject }.to_not change { stock_item.reload.count_on_hand } }
+      end
+    end
+  end
 end

data/spec/models/spree/returns_calculator_spec.rb

@@ -8,7 +8,7 @@ module Spree
     it 'compute_shipment must be overridden' do
       expect {
         subject.compute(return_item)
-      }.to raise_error
+      }.to raise_error(NotImplementedError)
     end
   end
 end

data/spec/models/spree/role_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Spree::Role, type: :model do
+  describe 'Associations' do
+    it { is_expected.to have_many(:role_users).class_name('Spree::RoleUser').dependent(:destroy) }
+  end
+end

data/spec/models/spree/shipment_spec.rb

@@ -41,7 +41,7 @@ describe Spree::Shipment, :type => :model do
   # Regression test for #4063
   context "number generation" do
     before do
-      allow(order).to receive :update!
+      allow(order).to receive :update_with_updater!
     end
 
     it "generates a number containing a letter + 11 numbers" do
@@ -394,7 +394,7 @@ describe Spree::Shipment, :type => :model do
 
   context "#cancel" do
     it 'cancels the shipment' do
-      allow(shipment.order).to receive(:update!)
+      allow(shipment.order).to receive(:update_with_updater!)
 
       shipment.state = 'pending'
       expect(shipment).to receive(:after_cancel)
@@ -439,33 +439,33 @@ describe Spree::Shipment, :type => :model do
   end
 
   context "#resume" do
-    it 'will determine new state based on order' do
-      allow(shipment.order).to receive(:update!)
+    it 'transitions state to ready if the order is ready' do
+      allow(shipment.order).to receive(:update_with_updater!)
 
       shipment.state = 'canceled'
-      expect(shipment).to receive(:determine_state).and_return(:ready)
+      expect(shipment).to receive(:determine_state).and_return('ready')
       expect(shipment).to receive(:after_resume)
       shipment.resume!
       expect(shipment.state).to eq 'ready'
     end
 
-    it 'unstocks them items' do
-      allow(shipment).to receive_message_chain(inventory_units: [mock_model(Spree::InventoryUnit, line_item: line_item, variant: variant)])
-      shipment.stock_location = mock_model(Spree::StockLocation)
-      expect(shipment.stock_location).to receive(:unstock).with(variant, 1, shipment)
-      shipment.after_resume
-    end
-
-    it 'will determine new state based on order' do
-      allow(shipment.order).to receive(:update!)
+    it 'transitions state to pending if the order is not ready' do
+      allow(shipment.order).to receive(:update_with_updater!)
 
       shipment.state = 'canceled'
-      expect(shipment).to receive(:determine_state).twice.and_return('ready')
+      expect(shipment).to receive(:determine_state).and_return('pending')
       expect(shipment).to receive(:after_resume)
       shipment.resume!
       # Shipment is pending because order is already paid
       expect(shipment.state).to eq 'pending'
     end
+
+    it 'unstocks them items' do
+      allow(shipment).to receive_message_chain(inventory_units: [mock_model(Spree::InventoryUnit, line_item: line_item, variant: variant)])
+      shipment.stock_location = mock_model(Spree::StockLocation)
+      expect(shipment.stock_location).to receive(:unstock).with(variant, 1, shipment)
+      shipment.after_resume
+    end
   end
 
   context "#ship" do
@@ -473,7 +473,7 @@ describe Spree::Shipment, :type => :model do
       let(:shipment_with_inventory_units) { create(:shipment, order: create(:order_with_line_items), state: 'canceled') }
       let(:subject) { shipment_with_inventory_units.ship! }
       before do
-        allow(order).to receive(:update!)
+        allow(order).to receive(:update_with_updater!)
         allow(shipment_with_inventory_units).to receive_messages(require_inventory: false, update_order: true)
       end
 
@@ -489,7 +489,7 @@ describe Spree::Shipment, :type => :model do
     ['ready', 'canceled'].each do |state|
       context "from #{state}" do
         before do
-          allow(order).to receive(:update!)
+          allow(order).to receive(:update_with_updater!)
           allow(shipment).to receive_messages(require_inventory: false, update_order: true, state: state)
         end
 

data/spec/models/spree/shipping_calculator_spec.rb

@@ -25,13 +25,13 @@ module Spree
     it 'compute_shipment must be overridden' do
       expect {
         subject.compute_shipment(shipment)
-      }.to raise_error
+      }.to raise_error(NameError)
     end
 
     it 'compute_package must be overridden' do
       expect {
         subject.compute_package(package)
-      }.to raise_error
+      }.to raise_error(NotImplementedError)
     end
 
     it 'checks availability for a package' do

data/spec/models/spree/shipping_category_spec.rb

@@ -2,4 +2,18 @@ require 'spec_helper'
 
 describe Spree::ShippingCategory, :type => :model do
 
+  describe '#validations' do
+    it 'should have a valid factory' do
+      expect(FactoryGirl.build(:shipping_category)).to be_valid
+    end
+
+    it 'should require name' do
+      expect(FactoryGirl.build(:shipping_category, name: '')).not_to be_valid
+    end
+
+    it 'should validate uniqueness' do
+      FactoryGirl.create(:shipping_category, name: 'Test')
+      expect(FactoryGirl.build(:shipping_category, name: 'Test')).not_to be_valid
+    end
+  end
 end

data/spec/models/spree/shipping_method_spec.rb

@@ -42,8 +42,15 @@ describe Spree::ShippingMethod, :type => :model do
     end
 
     context "shipping category" do
-      it "validates presence of at least one" do
-        expect(subject.error_on(:base).size).to eq(1)
+      context "is required" do
+        it { expect(subject.error_on(:base).size).to eq(1) }
+        it 'adds error to base' do
+          expect(subject.error_on(:base)).to include(I18n.t(:required_shipping_category,
+                                                            scope: [
+                                                              :activerecord, :errors, :models,
+                                                              'spree/shipping_method', :attributes, :base
+                                                            ]))
+        end
       end
 
       context "one associated" do

data/spec/models/spree/shipping_rate_spec.rb

@@ -2,29 +2,32 @@
 
 require 'spec_helper'
 
-describe Spree::ShippingRate, :type => :model do
+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) }
+  let(:shipping_rate) do
+    Spree::ShippingRate.new shipment: shipment,
+                            shipping_method: shipping_method,
+                            cost: 10
+  end
 
   context "#display_price" do
     context "when tax included in price" do
+      let!(:default_zone) { create(:zone, default_tax: true) }
+      let(:default_tax_rate) do
+        create :tax_rate,
+               name: "VAT",
+               amount: 0.1,
+               included_in_price: true,
+               zone: default_zone
+      end
       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 }
+        before { shipping_rate.tax_rate = default_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})")
+          expect(shipping_rate.display_price.to_s).
+            to eq("$10.00 (incl. $0.91 #{default_tax_rate.name})")
         end
 
         context "when cost is zero" do
@@ -38,20 +41,21 @@ describe Spree::ShippingRate, :type => :model do
         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)
+      context "when the tax rate is from another zone" do
+        let!(:non_default_zone) { create(:zone, default_tax: false) }
+
+        let(:non_default_tax_rate) do
+          create :tax_rate,
+                 name: "VAT",
+                 amount: 0.2,
+                 included_in_price: true,
+                 zone: non_default_zone
         end
-        before { shipping_rate.tax_rate = tax_rate }
+        before { shipping_rate.tax_rate = non_default_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})")
+        it "deducts the other zone's VAT from the calculated shipping rate" do
+          expect(shipping_rate.display_price.to_s).
+            to eq("$10.00 (incl. $1.67 #{non_default_tax_rate.name})")
         end
 
         context "when cost is zero" do
@@ -67,11 +71,12 @@ describe Spree::ShippingRate, :type => :model do
     end
 
     context "when tax is additional to price" do
-      let(:tax_rate) { create(:tax_rate, :name => "Sales Tax", :amount => 0.1) }
+      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})")
+        expect(shipping_rate.display_price.to_s).
+          to eq("$10.00 (+ $1.00 #{tax_rate.name})")
       end
 
       context "when cost is zero" do
@@ -86,9 +91,9 @@ describe Spree::ShippingRate, :type => :model do
     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 }
+      let(:shipping_rate) { Spree::ShippingRate.new(cost: 205) }
+
+      before { allow(shipping_rate).to receive_messages(currency: "JPY") }
 
       it "displays the price in yen" do
         expect(shipping_rate.display_price.to_s).to eq("¥205")
@@ -103,7 +108,7 @@ describe Spree::ShippingRate, :type => :model do
     end
 
     it "can be retrieved even when deleted" do
-      shipping_method.update_column(:deleted_at, Time.now)
+      shipping_method.update_column(:deleted_at, Time.current)
       shipping_rate.save
       shipping_rate.reload
       expect(shipping_rate.shipping_method).to eq(shipping_method)
@@ -122,20 +127,14 @@ describe Spree::ShippingRate, :type => :model do
     end
 
     it "can be retrieved even when deleted" do
-      tax_rate.update_column(:deleted_at, Time.now)
+      tax_rate.update_column(:deleted_at, Time.current)
       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
+  describe 'delegate' do
+    it { is_expected.to delegate_method(:code).to(:shipping_method).with_prefix(true) }
   end
 end

data/spec/models/spree/state_spec.rb

@@ -1,6 +1,17 @@
 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")
     expect(Spree::State.find_all_by_name_or_abbr("California")).to include(state)

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/estimator_spec.rb

@@ -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