spree_core 3.0.9 → 3.2.0

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,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Promotion::Rules::Taxon, :type => :model do
+describe Spree::Promotion::Rules::Taxon, type: :model do
   let(:rule){ subject }
 
   context '#elegible?(order)' do

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)

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

@@ -1,7 +1,15 @@
 require 'spec_helper'
 
-describe Spree::Promotion::Rules::User, :type => :model do
+describe Spree::Promotion::Rules::User, type: :model do
   let(:rule) { Spree::Promotion::Rules::User.new }
+  let(:test_user) { create :user }
+
+  describe 'Associations' do
+    it 'should have many promotion_rule_users' do
+      is_expected.to have_many(:promotion_rule_users).with_foreign_key(:promotion_rule_id).
+        class_name('Spree::PromotionRuleUser').dependent(:destroy)
+    end
+  end
 
   context "#eligible?(order)" do
     let(:order) { Spree::Order.new }
@@ -13,24 +21,24 @@ describe Spree::Promotion::Rules::User, :type => :model do
     it "should be eligible if users include user placing the order" do
       user = mock_model(Spree::LegacyUser)
       users = [user, mock_model(Spree::LegacyUser)]
-      allow(rule).to receive_messages(:users => users)
-      allow(order).to receive_messages(:user => user)
+      allow(rule).to receive_messages(users: users)
+      allow(order).to receive_messages(user: user)
 
       expect(rule).to be_eligible(order)
     end
 
     it "should not be eligible if user placing the order is not listed" do
-      allow(order).to receive_messages(:user => mock_model(Spree::LegacyUser))
+      allow(order).to receive_messages(user: mock_model(Spree::LegacyUser))
       users = [mock_model(Spree::LegacyUser), mock_model(Spree::LegacyUser)]
-      allow(rule).to receive_messages(:users => users)
+      allow(rule).to receive_messages(users: users)
 
       expect(rule).not_to be_eligible(order)
     end
 
     # Regression test for #3885
     it "can assign to user_ids" do
-      user1 = Spree::LegacyUser.create!(:email => "test1@example.com")
-      user2 = Spree::LegacyUser.create!(:email => "test2@example.com")
+      user1 = Spree::LegacyUser.create!(email: "test1@example.com")
+      user2 = Spree::LegacyUser.create!(email: "test2@example.com")
       expect { rule.user_ids = "#{user1.id}, #{user2.id}" }.not_to raise_error
     end
   end

data/spec/models/spree/promotion_action_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe Spree::PromotionAction, :type => :model do
+describe Spree::PromotionAction, type: :model do
 
   it "should force developer to implement 'perform' method" do
-    expect { MyAction.new.perform }.to raise_error
+    expect { MyAction.new.perform }.to raise_error(NameError)
   end
 
 end

data/spec/models/spree/promotion_category_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::PromotionCategory, :type => :model do
+describe Spree::PromotionCategory, type: :model do
   describe 'validation' do
     let(:name) { 'Nom' }
     subject { Spree::PromotionCategory.new name: name }

data/spec/models/spree/promotion_handler/cart_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module PromotionHandler
-    describe Cart, :type => :model do
+    describe Cart, type: :model do
       let(:line_item) { create(:line_item) }
       let(:order) { line_item.order }
 

data/spec/models/spree/promotion_handler/coupon_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module PromotionHandler
-    describe Coupon, :type => :model do
+    describe Coupon, type: :model do
       let(:order) { double("Order", coupon_code: "10off").as_null_object }
 
       subject { Coupon.new(order) }
@@ -47,14 +47,14 @@ module Spree
       end
 
       context "coupon code promotion doesnt exist" do
-        before { Promotion.create name: "promo", :code => nil }
+        before { Promotion.create name: "promo", code: nil }
 
         it "doesnt fetch any promotion" do
           expect(subject.promotion).to be_blank
         end
 
         context "with no actions defined" do
-          before { Promotion.create name: "promo", :code => "10off" }
+          before { Promotion.create name: "promo", code: "10off" }
 
           it "populates error message" do
             subject.apply
@@ -64,7 +64,7 @@ module Spree
       end
 
       context "existing coupon code promotion" do
-        let!(:promotion) { Promotion.create name: "promo", :code => "10off"  }
+        let!(:promotion) { Promotion.create name: "promo", code: "10off"  }
         let!(:action) { Promotion::Actions::CreateItemAdjustments.create(promotion: promotion, calculator: calculator) }
         let(:calculator) { Calculator::FlatRate.new(preferred_amount: 10) }
 
@@ -73,11 +73,11 @@ module Spree
         end
 
         context "with a per-item adjustment action" do
-          let(:order) { create(:order_with_line_items, :line_items_count => 3) }
+          let(:order) { create(:order_with_line_items, line_items_count: 3) }
 
           context "right coupon given" do
             context "with correct coupon code casing" do
-              before { allow(order).to receive_messages :coupon_code => "10off" }
+              before { allow(order).to receive_messages coupon_code: "10off" }
 
               it "successfully activates promo" do
                 expect(order.total).to eq(130)
@@ -100,7 +100,7 @@ module Spree
 
             # Regression test for #4211
             context "with incorrect coupon code casing" do
-              before { allow(order).to receive_messages :coupon_code => "10OFF" }
+              before { allow(order).to receive_messages coupon_code: "10OFF" }
               it "successfully activates promo" do
                 expect(order.total).to eq(130)
                 subject.apply
@@ -118,7 +118,7 @@ module Spree
             let!(:order) { Order.create }
 
             before do
-              allow(order).to receive_messages :coupon_code => "10off"
+              allow(order).to receive_messages coupon_code: "10off"
               calculator = Calculator::FlatRate.new(preferred_amount: 10)
               general_promo = Promotion.create name: "General Promo"
               general_action = Promotion::Actions::CreateItemAdjustments.create(promotion: general_promo, calculator: calculator)
@@ -137,9 +137,9 @@ module Spree
         context "with a free-shipping adjustment action" do
           let!(:action) { Promotion::Actions::FreeShipping.create(promotion: promotion) }
           context "right coupon code given" do
-            let(:order) { create(:order_with_line_items, :line_items_count => 3) }
+            let(:order) { create(:order_with_line_items, line_items_count: 3) }
 
-            before { allow(order).to receive_messages :coupon_code => "10off" }
+            before { allow(order).to receive_messages coupon_code: "10off" }
 
             it "successfully activates promo" do
               expect(order.total).to eq(130)
@@ -166,10 +166,10 @@ module Spree
 
             before do
               allow(order).to receive_messages({
-                :coupon_code => "10off",
+                coupon_code: "10off",
                 # These need to be here so that promotion adjustment "wins"
-                :item_total => 50,
-                :ship_total => 10
+                item_total: 50,
+                ship_total: 10
               })
             end
 
@@ -200,7 +200,7 @@ module Spree
               expect(coupon.successful?).to be true
 
               order_2 = create(:order)
-              allow(order_2).to receive_messages :coupon_code => "10off"
+              allow(order_2).to receive_messages coupon_code: "10off"
               coupon = Coupon.new(order_2)
               coupon.apply
               expect(coupon.successful?).to be false
@@ -210,7 +210,7 @@ module Spree
             context "when the a new coupon is less good" do
               let!(:action_5) { Promotion::Actions::CreateAdjustment.create(promotion: promotion_5, calculator: calculator_5) }
               let(:calculator_5) { Calculator::FlatRate.new(preferred_amount: 5) }
-              let!(:promotion_5) { Promotion.create name: "promo", :code => "5off"  }
+              let!(:promotion_5) { Promotion.create name: "promo", code: "5off"  }
 
               it 'notifies of better deal' do
                 subject.apply
@@ -225,23 +225,23 @@ module Spree
         context "for an order with taxable line items" do
           before(:each) do
             @country = create(:country)
-            @zone = create(:zone, :name => "Country Zone", :default_tax => true, :zone_members => [])
-            @zone.zone_members.create(:zoneable => @country)
-            @category = Spree::TaxCategory.create :name => "Taxable Foo"
+            @zone = create(:zone, name: "Country Zone", default_tax: true, zone_members: [])
+            @zone.zone_members.create(zoneable: @country)
+            @category = Spree::TaxCategory.create name: "Taxable Foo"
             @rate1 = Spree::TaxRate.create(
-                :amount => 0.10,
-                :calculator => Spree::Calculator::DefaultTax.create,
-                :tax_category => @category,
-                :zone => @zone
+                amount: 0.10,
+                calculator: Spree::Calculator::DefaultTax.create,
+                tax_category: @category,
+                zone: @zone
             )
 
             @order = Spree::Order.create!
-            allow(@order).to receive_messages :coupon_code => "10off"
+            allow(@order).to receive_messages coupon_code: "10off"
           end
           context "and the product price is less than promo discount" do
             before(:each) do
               3.times do |i|
-                taxable = create(:product, :tax_category => @category, :price => 9.0)
+                taxable = create(:product, tax_category: @category, price: 9.0)
                 @order.contents.add(taxable.master, 1)
               end
             end
@@ -259,7 +259,7 @@ module Spree
           context "and the product price is greater than promo discount" do
             before(:each) do
               3.times do |i|
-                taxable = create(:product, :tax_category => @category, :price => 11.0)
+                taxable = create(:product, tax_category: @category, price: 11.0)
                 @order.contents.add(taxable.master, 2)
               end
             end
@@ -276,15 +276,15 @@ module Spree
           end
           context "and multiple quantity per line item" do
             before(:each) do
-              twnty_off = Promotion.create name: "promo", :code => "20off"
+              twnty_off = Promotion.create name: "promo", code: "20off"
               twnty_off_calc = Calculator::FlatRate.new(preferred_amount: 20)
               Promotion::Actions::CreateItemAdjustments.create(promotion: twnty_off,
                                                                calculator: twnty_off_calc)
 
               allow(@order).to receive(:coupon_code).and_call_original
-              allow(@order).to receive_messages :coupon_code => "20off"
+              allow(@order).to receive_messages coupon_code: "20off"
               3.times do |i|
-                taxable = create(:product, :tax_category => @category, :price => 10.0)
+                taxable = create(:product, tax_category: @category, price: 10.0)
                 @order.contents.add(taxable.master, 2)
               end
             end

data/spec/models/spree/promotion_handler/page_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 module Spree
   module PromotionHandler
-    describe Page, :type => :model do
-      let(:order) { create(:order_with_line_items, :line_items_count => 1) }
+    describe Page, type: :model do
+      let(:order) { create(:order_with_line_items, line_items_count: 1) }
 
-      let(:promotion) { Promotion.create(name: "10% off", :path => '10off') }
+      let(:promotion) { Promotion.create(name: "10% off", path: '10off') }
       before do
         calculator = Calculator::FlatPercentItemTotal.new(preferred_flat_percent: 10)
-        action = Promotion::Actions::CreateItemAdjustments.create(:calculator => calculator)
+        action = Promotion::Actions::CreateItemAdjustments.create(calculator: calculator)
         promotion.actions << action
       end
 
@@ -21,8 +21,8 @@ module Spree
       context "when promotion is expired" do
         before do
           promotion.update_columns(
-            :starts_at => 1.week.ago,
-            :expires_at => 1.day.ago
+            starts_at: 1.week.ago,
+            expires_at: 1.day.ago
           )
         end
 

data/spec/models/spree/promotion_rule_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Spree::PromotionRule, :type => :model do
+  describe Spree::PromotionRule, type: :model do
 
     class BadTestRule < Spree::PromotionRule; end
 
@@ -12,7 +12,7 @@ module Spree
     end
 
     it "should force developer to implement eligible? method" do
-      expect { BadTestRule.new.eligible? }.to raise_error
+      expect { BadTestRule.new.eligible? }.to raise_error(ArgumentError)
     end
 
     it "validates unique rules for a promotion" do

data/spec/models/spree/promotion_rule_taxon_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Spree::PromotionRuleTaxon do
+  describe 'Validations' do
+    it { is_expected.to validate_presence_of(:promotion_rule) }
+    it { is_expected.to validate_presence_of(:taxon) }
+    it { is_expected.to validate_uniqueness_of(:promotion_rule_id).scoped_to(:taxon_id).allow_nil }
+  end
+end

data/spec/models/spree/promotion_rule_user_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Spree::PromotionRuleUser do
+  describe 'Validations' do
+    it { is_expected.to validate_presence_of(:promotion_rule) }
+    it { is_expected.to validate_presence_of(:user) }
+    it { is_expected.to validate_uniqueness_of(:user_id).scoped_to(:promotion_rule_id).allow_nil }
+  end
+end