spree_core 3.0.9 → 3.2.0

data/spec/models/spree/adjustable/adjustments_updater_spec.rb

@@ -9,8 +9,8 @@ module Spree
       let(:subject) { AdjustmentsUpdater.new(line_item) }
       let(:order_subject) { AdjustmentsUpdater.new(order) }
 
-      context '#update' do
-        it "updates a linked adjustment" do
+      describe '#update' do
+        it "updates all linked adjusters" do
           tax_rate = create(:tax_rate, amount: 0.05)
           create(:adjustment, order: order, source: tax_rate, adjustable: line_item)
           line_item.price = 10
@@ -21,266 +21,6 @@ module Spree
           expect(line_item.additional_tax_total).to eq(0.5)
         end
       end
-
-      context "taxes and promotions" do
-        let!(:tax_rate) do
-          create(:tax_rate, amount: 0.05)
-        end
-
-        let!(:promotion) do
-          Spree::Promotion.create(name: "$10 off")
-        end
-
-        let!(:promotion_action) do
-          calculator = Calculator::FlatRate.new(preferred_amount: 10)
-          Promotion::Actions::CreateItemAdjustments.create(calculator: calculator,
-                                                           promotion: promotion)
-        end
-
-        before do
-          line_item.price = 20
-          line_item.tax_category = tax_rate.tax_category
-          line_item.save
-          create(:adjustment, order: order, source: promotion_action, adjustable: line_item)
-        end
-
-        context "tax included in price" do
-          before do
-            create(:adjustment, source: tax_rate,
-                                adjustable: line_item,
-                                order: order,
-                                included: true)
-          end
-
-          it "tax has no bearing on final price" do
-            subject.update
-            line_item.reload
-            expect(line_item.included_tax_total).to eq(0.5)
-            expect(line_item.additional_tax_total).to eq(0)
-            expect(line_item.promo_total).to eq(-10)
-            expect(line_item.adjustment_total).to eq(-10)
-          end
-
-          it "tax linked to order" do
-            order_subject.update
-            order.reload
-            expect(order.included_tax_total).to eq(0.5)
-            expect(order.additional_tax_total).to eq(00)
-          end
-        end
-
-        context "tax excluded from price" do
-          before do
-            create(:adjustment, source: tax_rate,
-                                adjustable: line_item,
-                                order: order,
-                                included: false)
-          end
-
-          it "tax applies to line item" do
-            subject.update
-            line_item.reload
-            # Taxable amount is: $20 (base) - $10 (promotion) = $10
-            # Tax rate is 5% (of $10).
-            expect(line_item.included_tax_total).to eq(0)
-            expect(line_item.additional_tax_total).to eq(0.5)
-            expect(line_item.promo_total).to eq(-10)
-            expect(line_item.adjustment_total).to eq(-9.5)
-          end
-
-          it "tax linked to order" do
-            order_subject.update
-            order.reload
-            expect(order.included_tax_total).to eq(0)
-            expect(order.additional_tax_total).to eq(0.5)
-          end
-        end
-      end
-
-      context "best promotion is always applied" do
-        let(:calculator) { Calculator::FlatRate.new(preferred_amount: 10) }
-
-        let(:source) { Promotion::Actions::CreateItemAdjustments.create calculator: calculator }
-
-        def create_adjustment(label, amount)
-          create(:adjustment, order:      order,
-                              adjustable: line_item,
-                              source:     source,
-                              amount:     amount,
-                              state:      "closed",
-                              label:      label,
-                              mandatory:  false)
-        end
-
-        it "should make all but the most valuable promotion adjustment ineligible, " +
-           "leaving non promotion adjustments alone" do
-          create_adjustment("Promotion A", -100)
-          create_adjustment("Promotion B", -200)
-          create_adjustment("Promotion C", -300)
-          create(:adjustment, order:  order,
-                              adjustable:  line_item,
-                              source:  nil,
-                              amount:  -500,
-                              state:  "closed",
-                              label:  "Some other credit")
-          line_item.adjustments.each { |a| a.update_column(:eligible, true) }
-
-          subject.update
-
-          expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-          expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion C')
-        end
-
-        it "should choose the most recent promotion adjustment when amounts are equal" do
-          # Using Timecop is a regression test
-          Timecop.freeze do
-            create_adjustment("Promotion A", -200)
-            create_adjustment("Promotion B", -200)
-          end
-          line_item.adjustments.each { |a| a.update_column(:eligible, true) }
-
-          subject.update
-
-          expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-          expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion B')
-        end
-
-        context "when previously ineligible promotions become available" do
-          let(:order_promo1) do
-            create(:promotion,
-                   :with_order_adjustment,
-                   :with_item_total_rule,
-                   weighted_order_adjustment_amount: 5,
-                   item_total_threshold_amount: 10)
-          end
-
-          let(:order_promo2) do
-            create(:promotion,
-                   :with_order_adjustment,
-                   :with_item_total_rule,
-                   weighted_order_adjustment_amount: 10,
-                   item_total_threshold_amount: 20)
-          end
-
-          let(:order_promos) { [order_promo1, order_promo2] }
-
-          let(:line_item_promo1) do
-            create(:promotion,
-                   :with_line_item_adjustment,
-                   :with_item_total_rule,
-                   adjustment_rate: 2.5,
-                   item_total_threshold_amount: 10)
-          end
-
-          let(:line_item_promo2) do
-            create(:promotion,
-                   :with_line_item_adjustment,
-                   :with_item_total_rule,
-                   adjustment_rate: 5,
-                   item_total_threshold_amount: 20)
-          end
-
-          let(:line_item_promos) { [line_item_promo1, line_item_promo2] }
-          let(:order) { create(:order_with_line_items, line_items_count: 1) }
-
-          # Apply promotions in different sequences. Results should be the same.
-          promo_sequences = [[0, 1], [1, 0]]
-
-          promo_sequences.each do |promo_sequence|
-            it "should pick the best order-level promo according to current eligibility" do
-              # apply both promos to the order, even though only promo1 is eligible
-              order_promos[promo_sequence[0]].activate order: order
-              order_promos[promo_sequence[1]].activate order: order
-
-              order.reload
-              msg = "Expected two adjustments (using sequence #{promo_sequence})"
-              expect(order.all_adjustments.count).to eq(2), msg
-
-              msg = "Expected one elegible adjustment (using sequence #{promo_sequence})"
-              expect(order.all_adjustments.eligible.count).to eq(1), msg
-
-              msg = "Expected promo1 to be used (using sequence #{promo_sequence})"
-              expect(order.all_adjustments.eligible.first.source.promotion).to eq(order_promo1), msg
-
-              order.contents.add create(:variant, price: 10), 1
-              order.save
-
-              order.reload
-              msg = "Expected two adjustments (using sequence #{promo_sequence})"
-              expect(order.all_adjustments.count).to eq(2), msg
-
-              msg = "Expected one elegible adjustment (using sequence #{promo_sequence})"
-              expect(order.all_adjustments.eligible.count).to eq(1), msg
-
-              msg = "Expected promo2 to be used (using sequence #{promo_sequence})"
-              expect(order.all_adjustments.eligible.first.source.promotion).to eq(order_promo2), msg
-            end
-          end
-
-          promo_sequences.each do |promo_sequence|
-            it "should pick the best line-item-level promo according to current eligibility" do
-              # apply both promos to the order, even though only promo1 is eligible
-              line_item_promos[promo_sequence[0]].activate order: order
-              line_item_promos[promo_sequence[1]].activate order: order
-
-              order.reload
-              msg = "Expected one adjustment (using sequence #{promo_sequence})"
-              expect(order.all_adjustments.count).to eq(1), msg
-
-              msg = "Expected one elegible adjustment (using sequence #{promo_sequence})"
-              expect(order.all_adjustments.eligible.count).to eq(1), msg
-
-              # line_item_promo1 is the only one that has thus far met the order total threshold,
-              # it is the only promo which should be applied.
-              msg = "Expected line_item_promo1 to be used (using sequence #{promo_sequence})"
-              expect(order.all_adjustments.first.source.promotion).to eq(line_item_promo1), msg
-
-              order.contents.add create(:variant, price: 10), 1
-              order.save
-
-              order.reload
-              msg = "Expected four adjustments (using sequence #{promo_sequence})"
-              expect(order.all_adjustments.count).to eq(4), msg
-
-              msg = "Expected two elegible adjustments (using sequence #{promo_sequence})"
-              expect(order.all_adjustments.eligible.count).to eq(2), msg
-
-              order.all_adjustments.eligible.each do |adjustment|
-                msg = "Expected line_item_promo2 to be used (using sequence #{promo_sequence})"
-                expect(adjustment.source.promotion).to eq(line_item_promo2), msg
-              end
-            end
-          end
-        end
-
-        context "multiple adjustments and the best one is not eligible" do
-          let!(:promo_a) { create_adjustment("Promotion A", -100) }
-          let!(:promo_c) { create_adjustment("Promotion C", -300) }
-
-          before do
-            promo_a.update_column(:eligible, true)
-            promo_c.update_column(:eligible, false)
-          end
-
-          # regression for #3274
-          it "still makes the previous best eligible adjustment valid" do
-            subject.update
-            expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion A')
-          end
-        end
-
-        it "should only leave one adjustment even if 2 have the same amount" do
-          create_adjustment("Promotion A", -100)
-          create_adjustment("Promotion B", -200)
-          create_adjustment("Promotion C", -200)
-
-          subject.update
-
-          expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-          expect(line_item.adjustments.promotion.eligible.first.amount.to_i).to eq(-200)
-        end
-      end
-
     end
   end
 end

data/spec/models/spree/adjustment_spec.rb

@@ -3,16 +3,42 @@
 
 require 'spec_helper'
 
-describe Spree::Adjustment, :type => :model do
+describe Spree::Adjustment, type: :model do
 
   let(:order) { Spree::Order.new }
 
   before do
-    allow(order).to receive(:update!)
+    allow(order).to receive(:update_with_updater!)
   end
 
   let(:adjustment) { Spree::Adjustment.create!(label: 'Adjustment', adjustable: order, order: order, amount: 5) }
 
+  describe 'scopes' do
+    describe '.for_complete_order' do
+      let(:complete_order) { Spree::Order.create! completed_at: Time.current }
+      let(:incomplete_order) { Spree::Order.create! completed_at: nil }
+      let(:adjustment_for_complete_order) { Spree::Adjustment.create!(label: 'Adjustment', adjustable: complete_order, order: complete_order, amount: 5) }
+      let(:adjustment_for_incomplete_order) { Spree::Adjustment.create!(label: 'Adjustment', adjustable: incomplete_order, order: incomplete_order, amount: 5) }
+
+      subject { Spree::Adjustment.for_complete_order }
+
+      it { is_expected.to include(adjustment_for_complete_order) }
+      it { is_expected.to_not include(adjustment_for_incomplete_order) }
+    end
+
+    describe '.for_incomplete_order' do
+      let(:complete_order) { Spree::Order.create! completed_at: Time.current }
+      let(:incomplete_order) { Spree::Order.create! completed_at: nil }
+      let(:adjustment_for_complete_order) { Spree::Adjustment.create!(label: 'Adjustment', adjustable: complete_order, order: complete_order, amount: 5) }
+      let(:adjustment_for_incomplete_order) { Spree::Adjustment.create!(label: 'Adjustment', adjustable: incomplete_order, order: incomplete_order, amount: 5) }
+
+      subject { Spree::Adjustment.for_incomplete_order }
+
+      it { is_expected.to_not include(adjustment_for_complete_order) }
+      it { is_expected.to include(adjustment_for_incomplete_order) }
+    end
+  end
+
   context '#create & #destroy' do
     let(:adjustment) { Spree::Adjustment.new(label: "Adjustment", amount: 5, order: order, adjustable: create(:line_item)) }
 

data/spec/models/spree/app_configuration_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
-describe Spree::AppConfiguration, :type => :model do
-
+describe Spree::AppConfiguration, type: :model do
   let (:prefs) { Rails.application.config.spree.preferences }
 
   it "should be available from the environment" do
@@ -19,5 +18,9 @@ describe Spree::AppConfiguration, :type => :model do
     expect(prefs.searcher_class).to eq Spree::Core::Search::Base
   end
 
+  describe 'admin_path' do
+    it { expect(Spree::Config).to have_preference(:admin_path) }
+    it { expect(Spree::Config.preferred_admin_path_type).to eq(:string) }
+    it { expect(Spree::Config.preferred_admin_path_default).to eq('/admin') }
+  end
 end
-

data/spec/models/spree/asset_spec.rb

@@ -1,14 +1,17 @@
 require 'spec_helper'
 
-describe Spree::Asset, :type => :model do
+describe Spree::Asset, type: :model do
   describe "#viewable" do
     it "touches association" do
-      product = create(:custom_product)
-      asset = Spree::Asset.create! { |a| a.viewable = product.master }
+      Timecop.scale(3600) do
 
-      expect do
-        asset.touch
-      end.to change { product.reload.updated_at }
+        product = create(:custom_product)
+        asset   = Spree::Asset.create! { |a| a.viewable = product.master }
+
+        expect do
+          asset.touch
+        end.to change { product.reload.updated_at }
+      end
     end
   end
 

data/spec/models/spree/calculator/default_tax_spec.rb

@@ -1,23 +1,23 @@
 require 'spec_helper'
 
-describe Spree::Calculator::DefaultTax, :type => :model do
+describe Spree::Calculator::DefaultTax, type: :model do
   let!(:country) { create(:country) }
-  let!(:zone) { create(:zone, :name => "Country Zone", :default_tax => true, :zone_members => []) }
-  let!(:tax_category) { create(:tax_category, :tax_rates => []) }
-  let!(:rate) { create(:tax_rate, :tax_category => tax_category, :amount => 0.05, :included_in_price => included_in_price) }
+  let!(:zone) { create(:zone, name: "Country Zone", default_tax: true, zone_members: []) }
+  let!(:tax_category) { create(:tax_category, tax_rates: []) }
+  let!(:rate) { create(:tax_rate, tax_category: tax_category, amount: 0.05, included_in_price: included_in_price) }
   let(:included_in_price) { false }
-  let!(:calculator) { Spree::Calculator::DefaultTax.new(:calculable => rate ) }
+  let!(:calculator) { Spree::Calculator::DefaultTax.new(calculable: rate) }
   let!(:order) { create(:order) }
-  let!(:line_item) { create(:line_item, :price => 10, :quantity => 3, :tax_category => tax_category) }
-  let!(:shipment) { create(:shipment, :cost => 15) }
+  let!(:line_item) { create(:line_item, price: 10, quantity: 3, tax_category: tax_category) }
+  let!(:shipment) { create(:shipment, cost: 15) }
 
   context "#compute" do
     context "when given an order" do
       let!(:line_item_1) { line_item }
-      let!(:line_item_2) { create(:line_item, :price => 10, :quantity => 3, :tax_category => tax_category) }
+      let!(:line_item_2) { create(:line_item, price: 10, quantity: 3, tax_category: tax_category) }
 
       before do
-        allow(order).to receive_messages :line_items => [line_item_1, line_item_2]
+        allow(order).to receive_messages line_items: [line_item_1, line_item_2]
       end
 
       context "when no line items match the tax category" do
@@ -51,7 +51,6 @@ describe Spree::Calculator::DefaultTax, :type => :model do
             # Amount is 0.51665, which will be rounded to...
             expect(calculator.compute(order)).to eq(0.52)
           end
-
         end
       end
 
@@ -77,10 +76,9 @@ describe Spree::Calculator::DefaultTax, :type => :model do
     context "when tax is included in price" do
       let(:included_in_price) { true }
       context "when the variant matches the tax category" do
-
         context "when line item is discounted" do
           before do
-            line_item.promo_total = -1
+            line_item.taxable_adjustment_total = -1
             Spree::TaxRate.store_pre_tax_amount(line_item, [rate])
           end
 
@@ -88,7 +86,6 @@ describe Spree::Calculator::DefaultTax, :type => :model do
             expect(calculator.compute(line_item)).to eql 1.38
           end
         end
-
         it "should be equal to the item's full price * rate" do
           Spree::TaxRate.store_pre_tax_amount(line_item, [rate])
           expect(calculator.compute(line_item)).to eql 1.43
@@ -98,7 +95,7 @@ describe Spree::Calculator::DefaultTax, :type => :model do
 
     context "when tax is not included in price" do
       context "when the line item is discounted" do
-        before { line_item.promo_total = -1 }
+        before { line_item.taxable_adjustment_total = -1 }
 
         it "should be equal to the item's pre-tax total * rate" do
           expect(calculator.compute(line_item)).to eq(1.45)
@@ -124,4 +121,32 @@ describe Spree::Calculator::DefaultTax, :type => :model do
       end
     end
   end
+
+  context "when given a line_item" do
+    let(:rate) { create(:tax_rate, amount: 0.07, included_in_price: true) }
+    let(:line_item) { create(:line_item, quantity: 50, price: 8.50) }
+
+    subject do
+      Spree::Calculator::DefaultTax.new(calculable: rate).
+        compute_line_item(line_item)
+    end
+
+    describe "#compute_line_item" do
+      it "computes the line item right" do
+        Spree::TaxRate.store_pre_tax_amount(line_item, [rate])
+        expect(subject).to eq(27.80)
+      end
+
+      context "with a 40$ promo" do
+        before do
+          allow(line_item).to receive(:taxable_adjustment_total).and_return(BigDecimal.new("-40"))
+          Spree::TaxRate.store_pre_tax_amount(line_item, [rate])
+        end
+
+        it "computes the line item right" do
+          expect(subject).to eq(25.19)
+        end
+      end
+    end
+  end
 end

data/spec/models/spree/calculator/flat_percent_item_total_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Calculator::FlatPercentItemTotal, :type => :model do
+describe Spree::Calculator::FlatPercentItemTotal, type: :model do
   let(:calculator) { Spree::Calculator::FlatPercentItemTotal.new }
   let(:line_item) { mock_model Spree::LineItem }
 

data/spec/models/spree/calculator/flexi_rate_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Calculator::FlexiRate, :type => :model do
+describe Spree::Calculator::FlexiRate, type: :model do
   let(:calculator) { Spree::Calculator::FlexiRate.new }
 
   let(:order) do
@@ -15,27 +15,27 @@ describe Spree::Calculator::FlexiRate, :type => :model do
     end
 
     it "should compute amount correctly when first_item has a value" do
-      allow(calculator).to receive_messages :preferred_first_item => 1.0
+      allow(calculator).to receive_messages preferred_first_item: 1.0
       expect(calculator.compute(order).round(2)).to eq(1.0)
     end
 
     it "should compute amount correctly when additional_items has a value" do
-      allow(calculator).to receive_messages :preferred_additional_item => 1.0
+      allow(calculator).to receive_messages preferred_additional_item: 1.0
       expect(calculator.compute(order).round(2)).to eq(9.0)
     end
 
     it "should compute amount correctly when additional_items and first_item have values" do
-      allow(calculator).to receive_messages :preferred_first_item => 5.0, :preferred_additional_item => 1.0
+      allow(calculator).to receive_messages preferred_first_item: 5.0, preferred_additional_item: 1.0
       expect(calculator.compute(order).round(2)).to eq(14.0)
     end
 
     it "should compute amount correctly when additional_items and first_item have values AND max items has value" do
-      allow(calculator).to receive_messages :preferred_first_item => 5.0, :preferred_additional_item => 1.0, :preferred_max_items => 3
+      allow(calculator).to receive_messages preferred_first_item: 5.0, preferred_additional_item: 1.0, preferred_max_items: 3
       expect(calculator.compute(order).round(2)).to eq(7.0)
     end
 
     it "should allow creation of new object with all the attributes" do
-      Spree::Calculator::FlexiRate.new(:preferred_first_item => 1, :preferred_additional_item => 1, :preferred_max_items => 1)
+      Spree::Calculator::FlexiRate.new(preferred_first_item: 1, preferred_additional_item: 1, preferred_max_items: 1)
     end
   end
 end

data/spec/models/spree/calculator/percent_on_line_item_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   class Calculator
-    describe PercentOnLineItem, :type => :model do
+    describe PercentOnLineItem, type: :model do
       let(:line_item) { double("LineItem", amount: 100) }
 
       before { subject.preferred_percent = 15 }

data/spec/models/spree/calculator/price_sack_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Calculator::PriceSack, :type => :model do
+describe Spree::Calculator::PriceSack, type: :model do
   let(:calculator) do
     calculator = Spree::Calculator::PriceSack.new
     calculator.preferred_minimal_amount = 5
@@ -10,7 +10,7 @@ describe Spree::Calculator::PriceSack, :type => :model do
   end
 
   let(:order) { stub_model(Spree::Order) }
-  let(:shipment) { stub_model(Spree::Shipment, :amount => 10) }
+  let(:shipment) { stub_model(Spree::Shipment, amount: 10) }
 
   # Regression test for #714 and #739
   it "computes with an order object" do

data/spec/models/spree/calculator/refunds/default_refund_amount_spec.rb

@@ -1,10 +1,11 @@
 require 'spec_helper'
 
-describe Spree::Calculator::Returns::DefaultRefundAmount, :type => :model do
+describe Spree::Calculator::Returns::DefaultRefundAmount, type: :model do
   let(:order)           { create(:order) }
   let(:line_item_quantity) { 2 }
-  let(:pre_tax_amount)  { 100.0 }
-  let(:line_item)       { create(:line_item, price: 100.0, quantity: line_item_quantity, pre_tax_amount: pre_tax_amount) }
+  let(:item_price)      { 100.0 }
+  let(:pre_tax_amount)  { line_item_quantity * item_price }
+  let(:line_item)       { create(:line_item, price: item_price, quantity: line_item_quantity) }
   let(:inventory_unit) { build(:inventory_unit, order: order, line_item: line_item) }
   let(:return_item) { build(:return_item, inventory_unit: inventory_unit ) }
   let(:calculator) { Spree::Calculator::Returns::DefaultRefundAmount.new }
@@ -43,9 +44,4 @@ describe Spree::Calculator::Returns::DefaultRefundAmount, :type => :model do
 
     it { is_expected.to eq 0.0 }
   end
-
-  context "pre_tax_amount is zero" do
-    let(:pre_tax_amount)  { 0.0 }
-    it { should eq 0.0 }
-  end
 end

data/spec/models/spree/calculator/shipping/flat_percent_item_total_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 module Spree
   module Calculator::Shipping
-    describe FlatPercentItemTotal, :type => :model do
-      let(:variant1) { build(:variant, :price => 10.11) }
-      let(:variant2) { build(:variant, :price => 20.2222) }
+    describe FlatPercentItemTotal, type: :model do
+      let(:variant1) { build(:variant, price: 10.11) }
+      let(:variant2) { build(:variant, price: 20.2222) }
 
       let(:line_item1) { build(:line_item, variant: variant1) }
       let(:line_item2) { build(:line_item, variant: variant2) }
@@ -13,7 +13,7 @@ module Spree
         build(:stock_package, variants_contents: { variant1 => 2, variant2 => 1 })
       end
 
-      subject { FlatPercentItemTotal.new(:preferred_flat_percent => 10) }
+      subject { FlatPercentItemTotal.new(preferred_flat_percent: 10) }
 
       it "should round result correctly" do
         expect(subject.compute(package)).to eq(4.04)

data/spec/models/spree/calculator/shipping/flat_rate_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 module Spree
   module Calculator::Shipping
-    describe FlatRate, :type => :model do
-      subject { Calculator::Shipping::FlatRate.new(:preferred_amount => 4.00) }
+    describe FlatRate, type: :model do
+      subject { Calculator::Shipping::FlatRate.new(preferred_amount: 4.00) }
 
       it 'always returns the same rate' do
         expect(subject.compute(build(:stock_package_fulfilled))).to eql 4.00

data/spec/models/spree/calculator/shipping/flexi_rate_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 
 module Spree
   module Calculator::Shipping
-    describe FlexiRate, :type => :model do
-      let(:variant1) { build(:variant, :price => 10) }
-      let(:variant2) { build(:variant, :price => 20) }
+    describe FlexiRate, type: :model do
+      let(:variant1) { build(:variant, price: 10) }
+      let(:variant2) { build(:variant, price: 20) }
 
       let(:package) do
         build(:stock_package, variants_contents: { variant1 => 4, variant2 => 6 })
@@ -41,9 +41,9 @@ module Spree
         end
 
         it "should allow creation of new object with all the attributes" do
-          FlexiRate.new(:preferred_first_item => 1,
-                        :preferred_additional_item => 1,
-                        :preferred_max_items => 1)
+          FlexiRate.new(preferred_first_item: 1,
+                        preferred_additional_item: 1,
+                        preferred_max_items: 1)
         end
       end
     end

data/spec/models/spree/calculator/shipping/per_item_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module Calculator::Shipping
-    describe PerItem, :type => :model do
+    describe PerItem, type: :model do
       let(:variant1) { build(:variant) }
       let(:variant2) { build(:variant) }
 
@@ -10,7 +10,7 @@ module Spree
         build(:stock_package, variants_contents: { variant1 => 5, variant2 => 3 })
       end
 
-      subject { PerItem.new(:preferred_amount => 10) }
+      subject { PerItem.new(preferred_amount: 10) }
 
       it "correctly calculates per item shipping" do
         expect(subject.compute(package).to_f).to eq(80) # 5 x 10 + 3 x 10

data/spec/models/spree/calculator/tiered_flat_rate_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Calculator::TieredFlatRate, :type => :model do
+describe Spree::Calculator::TieredFlatRate, type: :model do
   let(:calculator) { Spree::Calculator::TieredFlatRate.new }
 
   describe "#valid?" do

data/spec/models/spree/calculator/tiered_percent_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Calculator::TieredPercent, :type => :model do
+describe Spree::Calculator::TieredPercent, type: :model do
   let(:calculator) { Spree::Calculator::TieredPercent.new }
 
   describe "#valid?" do