solidus_core 1.2.3 → 1.3.0.beta1

data/spec/models/spree/product_spec.rb

@@ -9,15 +9,14 @@ module ThirdParty
   end
 end
 
-describe Spree::Product, :type => :model do
-
+describe Spree::Product, type: :model do
   context 'product instance' do
     let(:product) { create(:product) }
-    let(:variant) { create(:variant, :product => product) }
+    let(:variant) { create(:variant, product: product) }
 
     context '#duplicate' do
       before do
-        allow(product).to receive_messages :taxons => [create(:taxon)]
+        allow(product).to receive_messages taxons: [create(:taxon)]
       end
 
       it 'duplicates product' do
@@ -122,7 +121,7 @@ describe Spree::Product, :type => :model do
 
     context "product has variants" do
       before do
-        create(:variant, :product => product)
+        create(:variant, product: product)
       end
 
       context "#destroy" do
@@ -189,7 +188,35 @@ describe Spree::Product, :type => :model do
       before { high.option_values.destroy_all }
 
       it "returns only variants with option values" do
-        expect(product.variants_and_option_values).to eq([low])
+        Spree::Deprecation.silence do
+          expect(product.variants_and_option_values).to eq([low])
+        end
+      end
+    end
+
+    context "variants_and_option_values_for" do
+      let!(:high) { create(:variant, product: product) }
+      let!(:low) { create(:variant, product: product) }
+
+      context "when one product does not have option values" do
+        before { high.option_values.destroy_all }
+
+        it "returns only variants with option values" do
+          expect(product.variants_and_option_values_for).to eq([low])
+        end
+      end
+
+      context "when asking with different pricing options" do
+        let(:pricing_options) { Spree::Config.pricing_options_class.new(currency: "EUR") }
+
+        before do
+          low.prices.create(amount: 99.00, currency: "EUR")
+        end
+
+        it "returns only variants which have matching prices" do
+          expect(product.variants_and_option_values_for).to contain_exactly(low, high)
+          expect(product.variants_and_option_values_for(pricing_options)).to contain_exactly(low)
+        end
       end
     end
 
@@ -278,7 +305,6 @@ describe Spree::Product, :type => :model do
     end
 
     context "slugs" do
-
       it "normalizes slug on update validation" do
         product.slug = "hey//joe"
         product.valid?
@@ -332,6 +358,13 @@ describe Spree::Product, :type => :model do
         end
       end
     end
+
+    context "#really_destroy!" do
+      it "destroy the product" do
+        product.really_destroy!
+        expect(product).not_to be_persisted
+      end
+    end
   end
 
   context "properties" do
@@ -362,11 +395,11 @@ describe Spree::Product, :type => :model do
 
     # Regression test for https://github.com/spree/spree/issues/2455
     it "should not overwrite properties' presentation names" do
-      Spree::Property.where(:name => 'foo').first_or_create!(:presentation => "Foo's Presentation Name")
+      Spree::Property.where(name: 'foo').first_or_create!(presentation: "Foo's Presentation Name")
       product.set_property('foo', 'value1')
       product.set_property('bar', 'value2')
-      expect(Spree::Property.where(:name => 'foo').first.presentation).to eq("Foo's Presentation Name")
-      expect(Spree::Property.where(:name => 'bar').first.presentation).to eq("bar")
+      expect(Spree::Property.where(name: 'foo').first.presentation).to eq("Foo's Presentation Name")
+      expect(Spree::Property.where(name: 'bar').first.presentation).to eq("bar")
     end
 
     # Regression test for https://github.com/spree/spree/issues/4416
@@ -402,16 +435,16 @@ describe Spree::Product, :type => :model do
 
     context "when prototype with option types is supplied" do
       def build_option_type_with_values(name, values)
-        ot = create(:option_type, :name => name)
+        ot = create(:option_type, name: name)
         values.each do |val|
-          ot.option_values.create(:name => val.downcase, :presentation => val)
+          ot.option_values.create(name: val.downcase, presentation: val)
         end
         ot
       end
 
       let(:prototype) do
         size = build_option_type_with_values("size", %w(Small Medium Large))
-        create(:prototype, :name => "Size", :option_types => [ size ])
+        create(:prototype, name: "Size", option_types: [size])
       end
 
       let(:option_values_hash) do
@@ -465,12 +498,12 @@ describe Spree::Product, :type => :model do
   context "#images" do
     let(:product) { create(:product) }
     let(:image) { File.open(File.expand_path('../../../fixtures/thinking-cat.jpg', __FILE__)) }
-    let(:params) { {:viewable_id => product.master.id, :viewable_type => 'Spree::Variant', :attachment => image, :alt => "position 2", :position => 2} }
+    let(:params) { { viewable_id: product.master.id, viewable_type: 'Spree::Variant', attachment: image, alt: "position 2", position: 2 } }
 
     before do
       Spree::Image.create(params)
-      Spree::Image.create(params.merge({:alt => "position 1", :position => 1}))
-      Spree::Image.create(params.merge({:viewable_type => 'ThirdParty::Extension', :alt => "position 1", :position => 2}))
+      Spree::Image.create(params.merge({ alt: "position 1", position: 1 }))
+      Spree::Image.create(params.merge({ viewable_type: 'ThirdParty::Extension', alt: "position 1", position: 2 }))
     end
 
     it "only looks for variant images" do
@@ -498,18 +531,18 @@ describe Spree::Product, :type => :model do
   context '#total_on_hand' do
     it 'should be infinite if track_inventory_levels is false' do
       Spree::Config[:track_inventory_levels] = false
-      expect(build(:product, :variants_including_master => [build(:master_variant)]).total_on_hand).to eql(Float::INFINITY)
+      expect(build(:product, variants_including_master: [build(:master_variant)]).total_on_hand).to eql(Float::INFINITY)
     end
 
     it 'should be infinite if variant is on demand' do
       Spree::Config[:track_inventory_levels] = true
-      expect(build(:product, :variants_including_master => [build(:on_demand_master_variant)]).total_on_hand).to eql(Float::INFINITY)
+      expect(build(:product, variants_including_master: [build(:on_demand_master_variant)]).total_on_hand).to eql(Float::INFINITY)
     end
 
     it 'should return sum of stock items count_on_hand' do
       product = create(:product)
       product.stock_items.first.set_count_on_hand 5
-      product.variants_including_master(true) # force load association
+      product.variants_including_master.reload # force load association
       expect(product.total_on_hand).to eql(5)
     end
 
@@ -545,7 +578,7 @@ describe Spree::Product, :type => :model do
     end
 
     context 'initializing with variant attributes' do
-      let(:attributes) { {sku: 'FOO'} }
+      let(:attributes) { { sku: 'FOO' } }
 
       it_behaves_like "new product with master"
 

data/spec/models/spree/promotion/actions/create_adjustment_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Spree::Promotion::Actions::CreateAdjustment, :type => :model do
-  let(:order) { create(:order_with_line_items, :line_items_count => 1) }
+describe Spree::Promotion::Actions::CreateAdjustment, type: :model do
+  let(:order) { create(:order_with_line_items, line_items_count: 1) }
   let(:promotion) { create(:promotion) }
   let(:action) { Spree::Promotion::Actions::CreateAdjustment.new }
   let(:payload) { { order: order } }
@@ -9,21 +9,19 @@ describe Spree::Promotion::Actions::CreateAdjustment, :type => :model do
   # From promotion spec:
   context "#perform" do
     before do
-      action.calculator = Spree::Calculator::FlatRate.new(:preferred_amount => 10)
+      action.calculator = Spree::Calculator::FlatRate.new(preferred_amount: 10)
       promotion.promotion_actions = [action]
-      allow(action).to receive_messages(:promotion => promotion)
+      allow(action).to receive_messages(promotion: promotion)
     end
 
-    # Regression test for https://github.com/spree/spree/issues/3966
-    it "does not apply an adjustment if the amount is 0" do
+    it "does apply an adjustment if the amount is 0" do
       action.calculator.preferred_amount = 0
       action.perform(payload)
-      expect(promotion.usage_count).to eq(0)
-      expect(order.adjustments.count).to eq(0)
+      expect(order.adjustments.count).to eq(1)
     end
 
     it "should create a discount with correct negative amount" do
-      order.shipments.create!(:cost => 10)
+      order.shipments.create!(cost: 10)
 
       action.perform(payload)
       expect(promotion.usage_count).to eq(0)
@@ -38,7 +36,7 @@ describe Spree::Promotion::Actions::CreateAdjustment, :type => :model do
     end
 
     it "should not create a discount when order already has one from this promotion" do
-      order.shipments.create!(:cost => 10)
+      order.shipments.create!(cost: 10)
 
       action.perform(payload)
       action.perform(payload)
@@ -62,7 +60,7 @@ describe Spree::Promotion::Actions::CreateAdjustment, :type => :model do
 
   context "#destroy" do
     before(:each) do
-      action.calculator = Spree::Calculator::FlatRate.new(:preferred_amount => 10)
+      action.calculator = Spree::Calculator::FlatRate.new(preferred_amount: 10)
       promotion.promotion_actions = [action]
     end
 
@@ -76,7 +74,7 @@ describe Spree::Promotion::Actions::CreateAdjustment, :type => :model do
 
     context "when order is complete" do
       let(:order) do
-        create(:completed_order_with_totals, :line_items_count => 1)
+        create(:completed_order_with_totals, line_items_count: 1)
       end
 
       before(:each) do

data/spec/models/spree/promotion/actions/create_item_adjustments_spec.rb

@@ -3,11 +3,11 @@ require 'spec_helper'
 module Spree
   class Promotion
     module Actions
-      describe CreateItemAdjustments, :type => :model do
+      describe CreateItemAdjustments, type: :model do
         let(:order) { create(:order) }
         let(:promotion) { create(:promotion) }
         let(:action) { CreateItemAdjustments.new }
-        let!(:line_item) { create(:line_item, :order => order) }
+        let!(:line_item) { create(:line_item, order: order) }
         let(:payload) { { order: order, promotion: promotion } }
 
         before do
@@ -19,7 +19,7 @@ module Spree
           # Regression test for https://github.com/spree/spree/issues/3966
           context "when calculator computes 0" do
             before do
-              allow(action).to receive_messages :compute_amount => 0
+              allow(action).to receive_messages compute_amount: 0
             end
 
             it "does not create an adjustment when calculator returns 0" do
@@ -31,7 +31,7 @@ module Spree
           context "when calculator returns a non-zero value" do
             before do
               promotion.promotion_actions = [action]
-              allow(action).to receive_messages :compute_amount => 10
+              allow(action).to receive_messages compute_amount: 10
             end
 
             it "creates adjustment with item as adjustable" do

data/spec/models/spree/promotion/actions/create_quantity_adjustments_spec.rb

@@ -28,15 +28,15 @@ module Spree::Promotion::Actions
           end
           context "and an item with a quantity of 2" do
             let(:quantity) { 2 }
-            it { is_expected.to eq -10 }
+            it { is_expected.to eq(-10) }
           end
           context "and an item with a quantity of 3" do
             let(:quantity) { 3 }
-            it { is_expected.to eq -10 }
+            it { is_expected.to eq(-10) }
           end
           context "and an item with a quantity of 4" do
             let(:quantity) { 4 }
-            it { is_expected.to eq -20 }
+            it { is_expected.to eq(-20) }
           end
         end
 
@@ -49,11 +49,11 @@ module Spree::Promotion::Actions
             before { action.perform({ order: order, promotion: promotion }) }
             describe "the adjustment for the first item" do
               let(:line_item) { item_a }
-              it { is_expected.to eq -10 }
+              it { is_expected.to eq(-10) }
             end
             describe "the adjustment for the second item" do
               let(:line_item) { item_b }
-              it { is_expected.to eq -5 }
+              it { is_expected.to eq(-5) }
             end
             describe "the adjustment for the third item" do
               let(:line_item) { item_c }
@@ -71,7 +71,7 @@ module Spree::Promotion::Actions
             FactoryGirl.create :line_item, order: other_order, quantity: 3
             action.perform({ order: other_order, promotion: promotion })
           end
-          it { is_expected.to eq -10 }
+          it { is_expected.to eq(-10) }
         end
       end
 
@@ -88,11 +88,11 @@ module Spree::Promotion::Actions
             let!(:item_b) { FactoryGirl.create :line_item, order: order, quantity: 1, price: 10 }
             describe "the adjustment for the first item" do
               let(:line_item) { item_a }
-              it { is_expected.to eq -2 }
+              it { is_expected.to eq(-2) }
             end
             describe "the adjustment for the second item" do
               let(:line_item) { item_b }
-              it { is_expected.to eq -1 }
+              it { is_expected.to eq(-1) }
             end
           end
 
@@ -101,7 +101,7 @@ module Spree::Promotion::Actions
             let!(:item_b) { FactoryGirl.create :line_item, order: order, quantity: 1, price: 20 }
             describe "the adjustment for the first item" do
               let(:line_item) { item_a }
-              it { is_expected.to eq -3 }
+              it { is_expected.to eq(-3) }
             end
             describe "the adjustment for the second item" do
               let(:line_item) { item_b }

data/spec/models/spree/promotion/actions/free_shipping_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Promotion::Actions::FreeShipping, :type => :model do
+describe Spree::Promotion::Actions::FreeShipping, type: :model do
   let(:order) { create(:completed_order_with_totals) }
   let(:promotion_code) { create(:promotion_code, value: 'somecode') }
   let(:promotion) { promotion_code.promotion }

data/spec/models/spree/promotion/rules/first_order_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Spree::Promotion::Rules::FirstOrder, :type => :model do
+describe Spree::Promotion::Rules::FirstOrder, type: :model do
   let(:rule) { Spree::Promotion::Rules::FirstOrder.new }
-  let(:order) { mock_model(Spree::Order, :user => nil, :email => nil) }
+  let(:order) { mock_model(Spree::Order, user: nil, email: nil) }
   let(:user) { mock_model(Spree::LegacyUser) }
 
   context "without a user or email" do
@@ -18,31 +18,31 @@ describe Spree::Promotion::Rules::FirstOrder, :type => :model do
     context "for a signed user" do
       context "with no completed orders" do
         before(:each) do
-          allow(user).to receive_message_chain(:orders, :complete => [])
+          allow(user).to receive_message_chain(:orders, complete: [])
         end
 
         specify do
-          allow(order).to receive_messages(:user => user)
+          allow(order).to receive_messages(user: user)
           expect(rule).to be_eligible(order)
         end
 
         it "should be eligible when user passed in payload data" do
-          expect(rule).to be_eligible(order, :user => user)
+          expect(rule).to be_eligible(order, user: user)
         end
       end
 
       context "with completed orders" do
         before(:each) do
-          allow(order).to receive_messages(:user => user)
+          allow(order).to receive_messages(user: user)
         end
 
         it "should be eligible when checked against first completed order" do
-          allow(user).to receive_message_chain(:orders, :complete => [order])
+          allow(user).to receive_message_chain(:orders, complete: [order])
           expect(rule).to be_eligible(order)
         end
 
         context "with another order" do
-          before { allow(user).to receive_message_chain(:orders, :complete => [mock_model(Spree::Order)]) }
+          before { allow(user).to receive_message_chain(:orders, complete: [mock_model(Spree::Order)]) }
           it { expect(rule).not_to be_eligible(order) }
           it "sets an error message" do
             rule.eligible?(order)
@@ -55,14 +55,14 @@ describe Spree::Promotion::Rules::FirstOrder, :type => :model do
 
     context "for a guest user" do
       let(:email) { 'user@spreecommerce.com' }
-      before { allow(order).to receive_messages :email => 'user@spreecommerce.com' }
+      before { allow(order).to receive_messages email: 'user@spreecommerce.com' }
 
       context "with no other orders" do
         it { expect(rule).to be_eligible(order) }
       end
 
       context "with another order" do
-        before { allow(rule).to receive_messages(:orders_by_email => [mock_model(Spree::Order)]) }
+        before { allow(rule).to receive_messages(orders_by_email: [mock_model(Spree::Order)]) }
         it { expect(rule).not_to be_eligible(order) }
         it "sets an error message" do
           rule.eligible?(order)

data/spec/models/spree/promotion/rules/item_total_spec.rb

@@ -1,24 +1,42 @@
 require 'spec_helper'
 
-describe Spree::Promotion::Rules::ItemTotal, :type => :model do
-  let(:rule) { Spree::Promotion::Rules::ItemTotal.new }
-  let(:order) { double(:order) }
-
-  before { rule.preferred_amount = 50 }
+describe Spree::Promotion::Rules::ItemTotal, type: :model do
+  let(:rule) do
+    Spree::Promotion::Rules::ItemTotal.new(
+      preferred_amount: preferred_amount,
+      preferred_operator: preferred_operator
+    )
+  end
+  let(:order) { double(:order, item_total: item_total, currency: order_currency) }
+  let(:preferred_amount) { 50 }
+  let(:order_currency) { 'USD' }
 
   context "preferred operator set to gt" do
-    before { rule.preferred_operator = 'gt' }
+    let(:preferred_operator) { 'gt' }
+
+    context "item total is greater than preferred amount" do
+      let(:item_total) { 51 }
+
+      it "should be eligible when item total is greater than preferred amount" do
+        expect(rule).to be_eligible(order)
+      end
+
+      context "when the order is a different currency" do
+        let(:order_currency) { "CAD" }
 
-    it "should be eligible when item total is greater than preferred amount" do
-      allow(order).to receive_messages :item_total => 51
-      expect(rule).to be_eligible(order)
+        it "is not eligible" do
+          expect(rule).not_to be_eligible(order)
+        end
+      end
     end
 
     context "when item total is equal to preferred amount" do
-      before { allow(order).to receive_messages item_total: 50 }
+      let(:item_total) { 50 }
+
       it "is not eligible" do
         expect(rule).not_to be_eligible(order)
       end
+
       it "set an error message" do
         rule.eligible?(order)
         expect(rule.eligibility_errors.full_messages.first).
@@ -27,10 +45,12 @@ describe Spree::Promotion::Rules::ItemTotal, :type => :model do
     end
 
     context "when item total is lower than preferred amount" do
-      before { allow(order).to receive_messages item_total: 49 }
+      let(:item_total) { 49 }
+
       it "is not eligible" do
         expect(rule).not_to be_eligible(order)
       end
+
       it "set an error message" do
         rule.eligible?(order)
         expect(rule.eligibility_errors.full_messages.first).
@@ -40,23 +60,47 @@ describe Spree::Promotion::Rules::ItemTotal, :type => :model do
   end
 
   context "preferred operator set to gte" do
-    before { rule.preferred_operator = 'gte' }
+    let(:preferred_operator) { 'gte' }
+
+    context "total is greater than preferred amount" do
+      let(:item_total) { 51 }
 
-    it "should be eligible when item total is greater than preferred amount" do
-      allow(order).to receive_messages :item_total => 51
-      expect(rule).to be_eligible(order)
+      it "should be eligible when item total is greater than preferred amount" do
+        expect(rule).to be_eligible(order)
+      end
+
+      context "when the order is a different currency" do
+        let(:order_currency) { "CAD" }
+
+        it "is not eligible" do
+          expect(rule).not_to be_eligible(order)
+        end
+      end
     end
 
-    it "should be eligible when item total is equal to preferred amount" do
-      allow(order).to receive_messages :item_total => 50
-      expect(rule).to be_eligible(order)
+    context "item total is equal to preferred amount" do
+      let(:item_total) { 50 }
+
+      it "should be eligible" do
+        expect(rule).to be_eligible(order)
+      end
+
+      context "when the order is a different currency" do
+        let(:order_currency) { "CAD" }
+
+        it "is not eligible" do
+          expect(rule).not_to be_eligible(order)
+        end
+      end
     end
 
     context "when item total is lower than preferred amount" do
-      before { allow(order).to receive_messages item_total: 49 }
+      let(:item_total) { 49 }
+
       it "is not eligible" do
         expect(rule).not_to be_eligible(order)
       end
+
       it "set an error message" do
         rule.eligible?(order)
         expect(rule.eligibility_errors.full_messages.first).

data/spec/models/spree/promotion/rules/one_use_per_user_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Promotion::Rules::OneUsePerUser, :type => :model do
+describe Spree::Promotion::Rules::OneUsePerUser, type: :model do
   let(:rule) { described_class.new }
 
   describe '#eligible?(order)' do

data/spec/models/spree/promotion/rules/product_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Promotion::Rules::Product, :type => :model do
+describe Spree::Promotion::Rules::Product, type: :model do
   let(:rule) { Spree::Promotion::Rules::Product.new(rule_options) }
   let(:rule_options) { {} }
 
@@ -8,7 +8,7 @@ describe Spree::Promotion::Rules::Product, :type => :model do
     let(:order) { Spree::Order.new }
 
     it "should be eligible if there are no products" do
-      allow(rule).to receive_messages(:eligible_products => [])
+      allow(rule).to receive_messages(eligible_products: [])
       expect(rule).to be_eligible(order)
     end
 
@@ -20,8 +20,8 @@ describe Spree::Promotion::Rules::Product, :type => :model do
       let(:rule_options) { super().merge(preferred_match_policy: 'any') }
 
       it "should be eligible if any of the products is in eligible products" do
-        allow(order).to receive_messages(:products => [@product1, @product2])
-        allow(rule).to receive_messages(:eligible_products => [@product2, @product3])
+        allow(order).to receive_messages(products: [@product1, @product2])
+        allow(rule).to receive_messages(eligible_products: [@product2, @product3])
         expect(rule).to be_eligible(order)
       end
 
@@ -43,8 +43,8 @@ describe Spree::Promotion::Rules::Product, :type => :model do
       let(:rule_options) { super().merge(preferred_match_policy: 'all') }
 
       it "should be eligible if all of the eligible products are ordered" do
-        allow(order).to receive_messages(:products => [@product3, @product2, @product1])
-        allow(rule).to receive_messages(:eligible_products => [@product2, @product3])
+        allow(order).to receive_messages(products: [@product3, @product2, @product1])
+        allow(rule).to receive_messages(eligible_products: [@product2, @product3])
         expect(rule).to be_eligible(order)
       end
 
@@ -66,8 +66,8 @@ describe Spree::Promotion::Rules::Product, :type => :model do
       let(:rule_options) { super().merge(preferred_match_policy: 'none') }
 
       it "should be eligible if none of the order's products are in eligible products" do
-        allow(order).to receive_messages(:products => [@product1])
-        allow(rule).to receive_messages(:eligible_products => [@product2, @product3])
+        allow(order).to receive_messages(products: [@product1])
+        allow(rule).to receive_messages(eligible_products: [@product2, @product3])
         expect(rule).to be_eligible(order)
       end
 

data/spec/models/spree/promotion/rules/taxon_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Spree::Promotion::Rules::Taxon, :type => :model do
+describe Spree::Promotion::Rules::Taxon, type: :model do
   let(:rule) { Spree::Promotion::Rules::Taxon.create!(promotion: create(:promotion)) }
 
   context '#elegible?(order)' do
     let(:taxon){ create :taxon, name: 'first' }
-    let(:taxon2){ create :taxon, name: 'second'}
+    let(:taxon2){ create :taxon, name: 'second' }
     let(:order){ create :order_with_line_items }
 
     before do
@@ -53,7 +53,7 @@ describe Spree::Promotion::Rules::Taxon, :type => :model do
         before do
           taxon.children << taxon2
           order.products.first.taxons << taxon2
-          rule.taxons << taxon2
+          rule.taxons << taxon
         end
 
         it{ expect(rule).to be_eligible(order) }
@@ -75,7 +75,7 @@ describe Spree::Promotion::Rules::Taxon, :type => :model do
       end
 
       context "when order does not have all prefered taxons" do
-        before { rule.taxons << taxon  }
+        before { rule.taxons << taxon }
         it { expect(rule).not_to be_eligible(order) }
         it "sets an error message" do
           rule.eligible?(order)

data/spec/models/spree/promotion/rules/user_logged_in_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Promotion::Rules::UserLoggedIn, :type => :model do
+describe Spree::Promotion::Rules::UserLoggedIn, type: :model do
   let(:rule) { Spree::Promotion::Rules::UserLoggedIn.new }
 
   context "#eligible?(order)" do
@@ -8,13 +8,13 @@ describe Spree::Promotion::Rules::UserLoggedIn, :type => :model do
 
     it "should be eligible if order has an associated user" do
       user = double('User')
-      allow(order).to receive_messages(:user => user)
+      allow(order).to receive_messages(user: user)
 
       expect(rule).to be_eligible(order)
     end
 
     context "when user is not logged in" do
-      before { allow(order).to receive_messages(:user => nil) } # better to be explicit here
+      before { allow(order).to receive_messages(user: nil) } # better to be explicit here
       it { expect(rule).not_to be_eligible(order) }
       it "sets an error message" do
         rule.eligible?(order)
@@ -24,4 +24,3 @@ describe Spree::Promotion::Rules::UserLoggedIn, :type => :model do
     end
   end
 end
-