spree_core 3.0.9 → 3.2.0

data/spec/models/spree/product_option_type_spec.rb

@@ -1,5 +1,9 @@
 require 'spec_helper'
 
-describe Spree::ProductOptionType, :type => :model do
-
+describe Spree::ProductOptionType do
+  describe 'Validations' do
+    it { is_expected.to validate_presence_of(:product) }
+    it { is_expected.to validate_presence_of(:option_type) }
+    it { is_expected.to validate_uniqueness_of(:product_id).scoped_to(:option_type_id).allow_nil }
+  end
 end

data/spec/models/spree/product_promotion_rule_spec.rb

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

data/spec/models/spree/product_property_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::ProductProperty, :type => :model do
+describe Spree::ProductProperty, type: :model do
   context "touching" do
     it "should update product" do
       pp = create(:product_property)
@@ -8,4 +8,19 @@ describe Spree::ProductProperty, :type => :model do
       pp.touch
     end
   end
+
+  context 'property_name=' do
+    before do
+      @pp = create(:product_property)
+    end
+
+    it "should assign property" do
+      @pp.property_name = "Size"
+      expect(@pp.property.name).to eq('Size')
+    end
+  end
+
+  context 'ransackable_associations' do
+    it { expect(Spree::ProductProperty.whitelisted_ransackable_associations).to include('property') }
+  end
 end

data/spec/models/spree/product_spec.rb

@@ -9,15 +9,42 @@ module ThirdParty
   end
 end
 
-describe Spree::Product, :type => :model do
+describe Spree::Product, type: :model do
+
+  describe 'Associations' do
+    it 'should have many promotions' do
+      is_expected.to have_many(:promotions).
+        class_name('Spree::Promotion').through(:promotion_rules)
+    end
+
+    it 'should have many possible_promotions' do
+      is_expected.to have_many(:possible_promotions).
+        class_name('Spree::Promotion').through(:promotion_rules).source(:promotion)
+    end
+
+    it do
+      is_expected.to have_many(:variants).
+        class_name('Spree::Variant').
+        inverse_of(:product).
+        conditions(is_master: false).
+        order(:position)
+    end
+
+    it do
+      is_expected.to have_many(:variants_including_master).
+        class_name('Spree::Variant').
+        inverse_of(:product).
+        order(:position)
+    end
+  end
 
   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
@@ -88,7 +115,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
@@ -148,6 +175,17 @@ describe Spree::Product, :type => :model do
       end
     end
 
+    context "#can_supply?" do
+      it "should be true" do
+        expect(product.can_supply?).to be(true)
+      end
+
+      it "should be false" do
+        product.variants_including_master.each { |v| v.stock_items.update_all count_on_hand: 0, backorderable: false }
+        expect(product.can_supply?).to be(false)
+      end
+    end
+
     context "variants_and_option_values" do
       let!(:high) { create(:variant, product: product) }
       let!(:low) { create(:variant, product: product) }
@@ -159,20 +197,6 @@ describe Spree::Product, :type => :model do
       end
     end
 
-    describe 'Variants sorting' do
-      context 'without master variant' do
-        it 'sorts variants by position' do
-          expect(product.variants.to_sql).to match(/ORDER BY (\`|\")spree_variants(\`|\").position ASC/)
-        end
-      end
-
-      context 'with master variant' do
-        it 'sorts variants by position' do
-          expect(product.variants_including_master.to_sql).to match(/ORDER BY (\`|\")spree_variants(\`|\").position ASC/)
-        end
-      end
-    end
-
     context "has stock movements" do
       let(:variant) { product.master }
       let(:stock_item) { variant.stock_items.first }
@@ -199,6 +223,16 @@ describe Spree::Product, :type => :model do
         expect(product.slug).not_to match "/"
       end
 
+      it "stores old slugs in FriendlyIds history" do
+        # create_slug is a private method, included by FriendlyId::History
+        # it's effect is rather complex and dependent on state and config.
+        # However, when a new slug is set, it should call slugs.create!
+        expect(product.slugs).to receive(:create!)
+        # Set it, otherwise the create_slug method avoids writing a new one
+        product.slug = "custom-slug"
+        product.run_callbacks :save
+      end
+
       context "when product destroyed" do
 
         it "renames slug" do
@@ -244,6 +278,40 @@ describe Spree::Product, :type => :model do
       end
     end
 
+    describe "#discontinue_on_must_be_later_than_available_on" do
+      before { product.available_on = Date.today }
+
+      context "available_on is a date earlier than discontinue_on" do
+        before { product.discontinue_on = 5.days.from_now }
+
+        it "is valid" do
+          expect(product).to be_valid
+        end
+      end
+
+      context "available_on is a date earlier than discontinue_on" do
+        before { product.discontinue_on = 5.days.ago }
+
+        context "is not valid" do
+          before { product.valid? }
+
+          it { expect(product).not_to be_valid }
+          it { expect(product.errors[:discontinue_on]).to include(I18n.t(:invalid_date_range, scope: 'activerecord.errors.models.spree/product.attributes.discontinue_on')) }
+        end
+      end
+
+      context "available_on and discontinue_on are nil" do
+        before do
+          product.discontinue_on = nil
+          product.available_on = nil
+        end
+
+        it "is valid" do
+          expect(product).to be_valid
+        end
+      end
+    end
+
     context "hard deletion" do
       it "doesnt raise ActiveRecordError error" do
         expect { product.really_destroy! }.to_not raise_error
@@ -298,29 +366,47 @@ describe Spree::Product, :type => :model do
       }.to change { product.properties.length }.by(1)
     end
 
+    context 'optional property_presentation' do
+      subject { Spree::Property.where(name: 'foo').first.presentation }
+      let(:name) { 'foo' }
+      let(:presentation) { 'baz' }
+
+      describe 'is not used' do
+        before { product.set_property(name, 'bar') }
+        it { is_expected.to eq name }
+      end
+
+      describe 'is used' do
+        before { product.set_property(name, 'bar', presentation) }
+        it { is_expected.to eq presentation }
+      end
+    end
+
     # Regression test for #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 #4416
     context "#possible_promotions" do
-      let!(:promotion) do
-        create(:promotion, advertise: true, starts_at: 1.day.ago)
-      end
-      let!(:rule) do
-        Spree::Promotion::Rules::Product.create(
-          promotion: promotion,
-          products: [product]
-        )
+      let!(:possible_promotion) { create(:promotion, advertise: true, starts_at: 1.day.ago) }
+      let!(:unadvertised_promotion) { create(:promotion, advertise: false, starts_at: 1.day.ago) }
+      let!(:inactive_promotion) { create(:promotion, advertise: true, starts_at: 1.day.since) }
+
+      before do
+        product.promotion_rules.create!(promotion: possible_promotion)
+        product.promotion_rules.create!(promotion: unadvertised_promotion)
+        product.promotion_rules.create!(promotion: inactive_promotion)
       end
 
       it "lists the promotion as a possible promotion" do
-        expect(product.possible_promotions).to include(promotion)
+        expect(product.possible_promotions).to include(possible_promotion)
+        expect(product.possible_promotions).to_not include(unadvertised_promotion)
+        expect(product.possible_promotions).to_not include(inactive_promotion)
       end
     end
   end
@@ -340,16 +426,14 @@ 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)
-        values.each do |val|
-          ot.option_values.create(:name => val.downcase, :presentation => val)
+        values.each_with_object(create :option_type, name: name) do |val, ot|
+          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
@@ -381,6 +465,7 @@ describe Spree::Product, :type => :model do
         product.option_values_hash = option_values_hash
         product.prototype_id = nil
         product.save
+        product.reload
         expect(product.option_type_ids.length).to eq(1)
         expect(product.option_type_ids).to eq(prototype.option_type_ids)
         expect(product.variants.length).to eq(3)
@@ -403,12 +488,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
@@ -438,17 +523,17 @@ describe Spree::Product, :type => :model 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.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
 
@@ -471,4 +556,74 @@ describe Spree::Product, :type => :model do
     product = Spree::Product.new
     expect(product.master.is_master).to be true
   end
+
+  context "#discontinue!" do
+    let(:product) { create(:product, sku: 'a-sku') }
+
+    it "sets the discontinued" do
+      product.discontinue!
+      product.reload
+      expect(product.discontinued?).to be(true)
+    end
+
+    it "changes updated_at" do
+      Timecop.scale(1000) do
+        expect { product.discontinue! }.to change { product.updated_at }
+      end
+    end
+  end
+
+  context "#discontinued?" do
+    let(:product_live) { build(:product, sku: "a-sku") }
+    it "should be false" do
+      expect(product_live.discontinued?).to be(false)
+    end
+
+    let(:product_discontinued) { build(:product, sku: "a-sku", discontinue_on: Time.now - 1.day)  }
+    it "should be true" do
+      expect(product_discontinued.discontinued?).to be(true)
+    end
+  end
+
+  context "acts_as_taggable" do
+    let(:product) { create(:product) }
+
+    it "should add tags" do
+      product.tag_list.add("awesome")
+      expect(product.tag_list).to include("awesome")
+    end
+
+    it "should remove tags" do
+      product.tag_list.remove("awesome")
+      expect(product.tag_list).to_not include("awesome")
+    end
+  end
+
+  context "#brand" do
+    let(:taxonomy) { create(:taxonomy, name: I18n.t('spree.taxonomy_brands_name')) }
+    let(:product) { create(:product, taxons: [taxonomy.taxons.first]) }
+
+    it 'should fetch Brand Taxon' do
+      expect(product.brand).to eql(taxonomy.taxons.first)
+    end
+  end
+
+  context "#category" do
+    let(:taxonomy) { create(:taxonomy, name: I18n.t('spree.taxonomy_categories_name')) }
+    let(:product) { create(:product, taxons: [taxonomy.taxons.first]) }
+
+    it 'should fetch Category Taxon' do
+      expect(product.category).to eql(taxonomy.taxons.first)
+    end
+  end
+
+  describe '#ensure_no_line_items' do
+    let(:product) { create(:product) }
+    let!(:line_item) { create(:line_item, variant: product.master) }
+
+    it 'should add error on product destroy' do
+      expect(product.destroy).to eq false
+      expect(product.errors[:base]).to include Spree.t(:cannot_destroy_if_attached_to_line_items)
+    end
+  end
 end

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

@@ -8,6 +8,69 @@ describe Spree::Promotion::Actions::CreateAdjustment, type: :model do
 
   it_behaves_like 'an adjustment source'
 
+  describe '#compute_amount' do
+    subject { described_class.new }
+
+    let(:shipping_discount) { 10 }
+    let(:order) do
+      double(:order, item_total: 30, ship_total: 10, shipping_discount: shipping_discount)
+    end
+
+    context 'when shipping_discount is applied' do
+      context 'and total is less than discount' do
+        it 'returns discount amount eq to total' do
+          allow(subject).to receive(:compute).with(order).and_return(100)
+
+          expect(subject.compute_amount(order)).to eq -30
+        end
+      end
+
+      context 'and total is equal to discount' do
+        it 'returns discount amount' do
+          allow(subject).to receive(:compute).with(order).and_return(30)
+
+          expect(subject.compute_amount(order)).to eq -30
+        end
+      end
+
+      context 'and total is greater than discount' do
+        it 'returns discount amount' do
+          allow(subject).to receive(:compute).with(order).and_return(10)
+
+          expect(subject.compute_amount(order)).to eq -10
+        end
+      end
+    end
+
+    context 'when shipping_discount is not applied' do
+      let(:shipping_discount) { 0 }
+
+      context 'and total is less than discount' do
+        it 'returns discount amount eq to total' do
+          allow(subject).to receive(:compute).with(order).and_return(100)
+
+          expect(subject.compute_amount(order)).to eq -40
+        end
+      end
+
+      context 'and total is equal to discount' do
+        it 'returns discount amount' do
+          allow(subject).to receive(:compute).with(order).and_return(40)
+
+          expect(subject.compute_amount(order)).to eq -40
+        end
+      end
+
+      context 'and total is greater than discount' do
+        it 'returns discount amount' do
+          allow(subject).to receive(:compute).with(order).and_return(10)
+
+          expect(subject.compute_amount(order)).to eq -10
+        end
+      end
+    end
+  end
+
   # From promotion spec:
   context "#perform" do
     before 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
@@ -21,7 +21,7 @@ module Spree
           # Regression test for #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
@@ -33,7 +33,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
@@ -53,7 +53,7 @@ module Spree
             end
 
             context "with products rules" do
-              let!(:second_line_item) { create(:line_item, :order => order) }
+              let!(:second_line_item) { create(:line_item, order: order) }
               let(:rule) { double Spree::Promotion::Rules::Product }
 
               before do
@@ -120,7 +120,7 @@ module Spree
           end
 
           it "nullifies adjustments for completed orders" do
-            order = Order.create(completed_at: Time.now)
+            order = Order.create(completed_at: Time.current)
             adjustment = action.adjustments.create!(label: "Check",
                                                     amount: 0,
                                                     order: order,

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) { create(:promotion) }
   let(:action) { Spree::Promotion::Actions::FreeShipping.create }

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Spree::Promotion::Rules::Country, type: :model do
+  let(:rule) { Spree::Promotion::Rules::Country.new }
+  let(:order) { create(:order) }
+  let(:country) { create(:country) }
+  let(:other_country) { create(:country) }
+
+  before { allow(Spree::Country).to receive(:default) { other_country.id } }
+
+  context 'preferred country is set' do
+    before { rule.preferred_country_id = country.id }
+
+    it 'should be eligible for correct country' do
+      allow(order).to receive_message_chain(:ship_address, :country_id) { country.id }
+      expect(rule).to be_eligible(order)
+    end
+
+    it 'should not be eligible for incorrect country' do
+      allow(order).to receive_message_chain(:ship_address, :country_id) { other_country.id }
+      expect(rule).not_to be_eligible(order)
+    end
+  end
+
+  context 'preferred country is not set' do
+    it 'should be eligible for default country' do
+      allow(order).to receive_message_chain(:ship_address, :country_id) { other_country.id }
+      expect(rule).to be_eligible(order)
+    end
+
+    it 'should not be eligible for incorrect country' do
+      allow(order).to receive_message_chain(:ship_address, :country_id) { country.id }
+      expect(rule).not_to be_eligible(order)
+    end
+  end
+end

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)
@@ -54,15 +54,15 @@ describe Spree::Promotion::Rules::FirstOrder, :type => :model do
     end
 
     context "for a guest user" do
-      let(:email) { 'user@spreecommerce.com' }
-      before { allow(order).to receive_messages :email => 'user@spreecommerce.com' }
+      let(:email) { 'user@spreecommerce.org' }
+      before { allow(order).to receive_messages email: 'user@spreecommerce.org' }
 
       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,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Promotion::Rules::ItemTotal, :type => :model do
+describe Spree::Promotion::Rules::ItemTotal, type: :model do
   let(:rule) { Spree::Promotion::Rules::ItemTotal.new }
   let(:order) { double(:order) }
 

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