spree_core 3.0.9 → 3.2.0

data/spec/models/spree/variant_spec.rb

@@ -2,11 +2,17 @@
 
 require 'spec_helper'
 
-describe Spree::Variant, :type => :model do
+describe Spree::Variant, type: :model do
   let!(:variant) { create(:variant) }
+  let(:master_variant) { create(:master_variant) }
 
   it_behaves_like 'default_price'
 
+  describe 'validations' do
+    it { expect(master_variant).to_not validate_presence_of(:option_values) }
+    it { expect(variant).to validate_presence_of(:option_values) }
+  end
+
   context 'sorting' do
     it 'responds to set_list_position' do
       expect(variant.respond_to?(:set_list_position)).to eq(true)
@@ -30,7 +36,7 @@ describe Spree::Variant, :type => :model do
 
     it "propagate to stock items" do
       expect_any_instance_of(Spree::StockLocation).to receive(:propagate_variant)
-      product.variants.create(:name => "Foobar")
+      create(:variant, product: product)
     end
 
     context "stock location has disable propagate all variants" do
@@ -38,7 +44,7 @@ describe Spree::Variant, :type => :model do
 
       it "propagate to stock items" do
         expect_any_instance_of(Spree::StockLocation).not_to receive(:propagate_variant)
-        product.variants.create(:name => "Foobar")
+        product.variants.create(name: "Foobar")
       end
     end
 
@@ -51,19 +57,123 @@ describe Spree::Variant, :type => :model do
       end
 
       context 'when a variant is created' do
-        before(:each) do
-          product.variants.create!(:name => 'any-name')
-        end
+        let!(:new_variant) { create(:variant, product: product) }
 
         it { expect(product.master).to_not be_in_stock }
       end
     end
   end
 
+  describe 'scope' do
+    describe '.not_discontinued' do
+      context 'when discontinued' do
+        let!(:discontinued_variant) { create(:variant, discontinue_on: Time.current - 1.day) }
+
+        it { expect(Spree::Variant.not_discontinued).not_to include(discontinued_variant) }
+      end
+
+      context 'when not discontinued' do
+        let!(:variant_2) { create(:variant, discontinue_on: Time.current + 1.day) }
+
+        it { expect(Spree::Variant.not_discontinued).to include(variant_2) }
+      end
+
+      context 'when discontinue_on not present' do
+        let!(:variant_2) { create(:variant, discontinue_on: nil) }
+
+        it { expect(Spree::Variant.not_discontinued).to include(variant_2) }
+      end
+    end
+
+    describe '.not_deleted' do
+      context 'when deleted' do
+        let!(:deleted_variant) { create(:variant, deleted_at: Time.current) }
+
+        it { expect(Spree::Variant.not_deleted).not_to include(deleted_variant) }
+      end
+
+      context 'when not deleted' do
+        let!(:variant_2) { create(:variant, deleted_at: nil) }
+
+        it { expect(Spree::Variant.not_deleted).to include(variant_2) }
+      end
+    end
+
+    describe '.for_currency_and_available_price_amount' do
+      let(:currency) { 'EUR' }
+
+      context 'when price with currency present' do
+        context 'when price has amount' do
+          let!(:price_1) { create(:price, currency: currency, variant: variant, amount: 10) }
+
+          it { expect(Spree::Variant.for_currency_and_available_price_amount(currency)).to include(variant) }
+        end
+
+        context 'when price do not have amount' do
+          let!(:price_1) { create(:price, currency: currency, variant: variant, amount: nil) }
+
+          it { expect(Spree::Variant.for_currency_and_available_price_amount(currency)).not_to include(variant) }
+        end
+      end
+
+      context 'when price with currency not present' do
+        let!(:unavailable_currency) { 'INR' }
+        context 'when price has amount' do
+          let!(:price_1) { create(:price, currency: unavailable_currency, variant: variant, amount: 10) }
+
+          it { expect(Spree::Variant.for_currency_and_available_price_amount(currency)).not_to include(variant) }
+        end
+
+        context 'when price do not have amount' do
+          let!(:price_1) { create(:price, currency: unavailable_currency, variant: variant, amount: nil) }
+
+          it { expect(Spree::Variant.for_currency_and_available_price_amount(currency)).not_to include(variant) }
+        end
+      end
+
+      context 'when multiple prices for same currency present' do
+        let!(:price_1) { create(:price, currency: currency, variant: variant) }
+        let!(:price_2) { create(:price, currency: currency, variant: variant) }
+
+        it 'should not duplicate variant' do
+          expect(Spree::Variant.for_currency_and_available_price_amount(currency)).to eq([variant])
+        end
+      end
+    end
+
+    describe '.active' do
+      let!(:variants) { [variant] }
+      let!(:currency) { 'EUR' }
+
+      before(:each) do
+        allow(Spree::Variant).to receive(:not_discontinued).and_return(variants)
+        allow(variants).to receive(:not_deleted).and_return(variants)
+        allow(variants).to receive(:for_currency_and_available_price_amount).with(currency).and_return(variants)
+      end
+
+      it 'should find not_discontinued variants' do
+        expect(Spree::Variant).to receive(:not_discontinued).and_return(variants)
+        Spree::Variant.active(currency)
+      end
+
+      it 'should find not_deleted variants' do
+        expect(variants).to receive(:not_deleted).and_return(variants)
+        Spree::Variant.active(currency)
+      end
+
+      it 'should find variants for_currency_and_available_price_amount' do
+        expect(variants).to receive(:for_currency_and_available_price_amount).with(currency).and_return(variants)
+        Spree::Variant.active(currency)
+      end
+
+      it { expect(Spree::Variant.active(currency)).to eq(variants) }
+    end
+  end
+
   context "product has other variants" do
     describe "option value accessors" do
       before {
-        @multi_variant = FactoryGirl.create :variant, :product => variant.product
+        @multi_variant = FactoryGirl.create :variant, product: variant.product
         variant.product.reload
       }
 
@@ -95,7 +205,7 @@ describe Spree::Variant, :type => :model do
     context "product has other variants" do
       describe "option value accessors" do
         before {
-          @multi_variant = create(:variant, :product => variant.product)
+          @multi_variant = create(:variant, product: variant.product)
           variant.product.reload
         }
 
@@ -172,7 +282,7 @@ describe Spree::Variant, :type => :model do
 
   describe '.price_in' do
     before do
-      variant.prices << create(:price, :variant => variant, :currency => "EUR", :amount => 33.33)
+      variant.prices << create(:price, variant: variant, currency: "EUR", amount: 33.33)
     end
     subject { variant.price_in(currency).display_amount }
 
@@ -203,7 +313,7 @@ describe Spree::Variant, :type => :model do
 
   describe '.amount_in' do
     before do
-      variant.prices << create(:price, :variant => variant, :currency => "EUR", :amount => 33.33)
+      variant.prices << create(:price, variant: variant, currency: "EUR", amount: 33.33)
     end
 
     subject { variant.amount_in(currency) }
@@ -235,13 +345,14 @@ describe Spree::Variant, :type => :model do
 
   # Regression test for #2432
   describe 'options_text' do
-    let!(:variant) { create(:variant, option_values: []) }
+    let!(:variant) { build(:variant, option_values: []) }
     let!(:master) { create(:master_variant) }
 
     before do
       # Order bar than foo
       variant.option_values << create(:option_value, {name: 'Foo', presentation: 'Foo', option_type: create(:option_type, position: 2, name: 'Foo Type', presentation: 'Foo Type')})
       variant.option_values << create(:option_value, {name: 'Bar', presentation: 'Bar', option_type: create(:option_type, position: 1, name: 'Bar Type', presentation: 'Bar Type')})
+      variant.save
     end
 
     it 'should order by bar than foo' do
@@ -251,7 +362,7 @@ describe Spree::Variant, :type => :model do
   end
 
   describe 'exchange_name' do
-    let!(:variant) { create(:variant, option_values: []) }
+    let!(:variant) { build(:variant, option_values: []) }
     let!(:master) { create(:master_variant) }
 
     before do
@@ -260,6 +371,7 @@ describe Spree::Variant, :type => :model do
                                                      presentation: 'Foo',
                                                      option_type: create(:option_type, position: 2, name: 'Foo Type', presentation: 'Foo Type')
                                                    })
+      variant.save
     end
 
     context 'master variant' do
@@ -277,7 +389,7 @@ describe Spree::Variant, :type => :model do
   end
 
   describe 'exchange_name' do
-    let!(:variant) { create(:variant, option_values: []) }
+    let!(:variant) { build(:variant, option_values: []) }
     let!(:master) { create(:master_variant) }
 
     before do
@@ -286,6 +398,7 @@ describe Spree::Variant, :type => :model do
                                                      presentation: 'Foo',
                                                      option_type: create(:option_type, position: 2, name: 'Foo Type', presentation: 'Foo Type')
                                                    })
+      variant.save
     end
 
     context 'master variant' do
@@ -303,7 +416,7 @@ describe Spree::Variant, :type => :model do
   end
 
   describe 'descriptive_name' do
-    let!(:variant) { create(:variant, option_values: []) }
+    let!(:variant) { build(:variant, option_values: []) }
     let!(:master) { create(:master_variant) }
 
     before do
@@ -312,6 +425,7 @@ describe Spree::Variant, :type => :model do
                                                      presentation: 'Foo',
                                                      option_type: create(:option_type, position: 2, name: 'Foo Type', presentation: 'Foo Type')
                                                    })
+      variant.save
     end
 
     context 'master variant' do
@@ -441,7 +555,7 @@ describe Spree::Variant, :type => :model do
     it "updates a product" do
       variant.product.update_column(:updated_at, 1.day.ago)
       variant.touch
-      expect(variant.product.reload.updated_at).to be_within(3.seconds).of(Time.now)
+      expect(variant.product.reload.updated_at).to be_within(3.seconds).of(Time.current)
     end
 
     it "clears the in_stock cache key" do
@@ -520,4 +634,185 @@ describe Spree::Variant, :type => :model do
       expect(variant.dimension).to eq (dimension_expected)
     end
   end
+
+  context "#discontinue!" do
+    let(:variant) { create(:variant) }
+
+    it "sets the discontinued" do
+      variant.discontinue!
+      variant.reload
+      expect(variant.discontinued?).to be(true)
+    end
+
+    it "changes updated_at" do
+      Timecop.scale(1000) do
+        expect { variant.discontinue! }.to change { variant.updated_at }
+      end
+    end
+  end
+
+  context "#discontinued?" do
+    let(:variant_live) { build(:variant) }
+    it "should be false" do
+      expect(variant_live.discontinued?).to be(false)
+    end
+
+    let(:variant_discontinued) { build(:variant, discontinue_on: Time.now - 1.day) }
+    it "should be true" do
+      expect(variant_discontinued.discontinued?).to be(true)
+    end
+  end
+
+  describe "#available?" do
+    let(:variant) { create(:variant) }
+    context 'when discontinued' do
+      before(:each) do
+        variant.discontinue_on = Time.current - 1.day
+      end
+
+      context 'when product is available' do
+        before(:each) do
+          allow(variant.product).to receive(:available?) { true }
+        end
+
+        it { expect(variant.available?).to be(false) }
+      end
+
+      context 'when product is not available' do
+        before(:each) do
+          allow(variant.product).to receive(:available?) { false }
+        end
+
+        it { expect(variant.available?).to be(false) }
+      end
+    end
+
+    context 'when not discontinued' do
+      before(:each) do
+        variant.discontinue_on = Time.current + 1.day
+      end
+
+      context 'when product is available' do
+        before(:each) do
+          allow(variant.product).to receive(:available?) { true }
+        end
+
+        it { expect(variant.available?).to be(true) }
+      end
+
+      context 'when product is not available' do
+        before(:each) do
+          allow(variant.product).to receive(:available?) { false }
+        end
+
+        it { expect(variant.available?).to be(false) }
+      end
+    end
+  end
+
+  describe "#check_price" do
+    let(:variant) { create(:variant) }
+    let(:variant2) { create(:variant) }
+
+    context 'require_master_price set false' do
+      before { Spree::Config.set(require_master_price: false) }
+
+      context 'price present and currency present' do
+        it { expect(variant.send(:check_price)).to be(nil) }
+      end
+
+      context 'price present and currency nil' do
+        before { variant.currency = nil }
+
+        it { expect(variant.send(:check_price)).to be(Spree::Config[:currency]) }
+      end
+
+      context 'price nil and currency present' do
+        before { variant.price = nil }
+
+        it { expect(variant.send(:check_price)).to be(nil) }
+      end
+
+      context 'price nil and currency nil' do
+        before { variant.price = nil }
+
+        it { expect(variant.send(:check_price)).to be(nil) }
+      end
+    end
+
+    context 'require_master_price set true' do
+      before { Spree::Config.set(require_master_price: true) }
+
+      context 'price present and currency present' do
+        it { expect(variant.send(:check_price)).to be(nil) }
+      end
+
+      context 'price present and currency nil' do
+        before { variant.currency = nil }
+
+        it { expect(variant.send(:check_price)).to be(Spree::Config[:currency]) }
+      end
+
+      context 'product and master_variant present and equal' do
+        context 'price nil and currency present' do
+          before { variant.price = nil }
+          it { expect(variant.send(:check_price)).to be(nil) }
+
+          context 'check variant price' do
+            before { variant.send(:check_price) }
+            it { expect(variant.price).to eq(variant.product.master.price) }
+          end
+        end
+
+        context 'price nil and currency nil' do
+          before do
+            variant.price = nil
+            variant.send(:check_price)
+          end
+
+          it { expect(variant.price).to eq(variant.product.master.price) }
+          it { expect(variant.currency).to eq(Spree::Config[:currency]) }
+        end
+      end
+
+      context 'product not present' do
+        context 'product not present' do
+          before { variant.product = nil }
+
+          context 'price nil and currency present' do
+            before { variant.price = nil }
+
+            it { expect { variant.send(:check_price) }.to raise_error(RuntimeError, 'No master variant found to infer price') }
+          end
+
+          context 'price nil and currency nil' do
+            before { variant.price = nil }
+
+            it { expect { variant.send(:check_price) }.to raise_error(RuntimeError, 'No master variant found to infer price') }
+          end
+        end
+      end
+    end
+  end
+
+  describe '#created_at' do
+    it 'creates variant with created_at timestamp' do
+      expect(variant.created_at).to_not be_nil
+    end
+  end
+
+  describe '#updated_at' do
+    it 'creates variant with updated_at timestamp' do
+      expect(variant.updated_at).to_not be_nil
+    end
+  end
+
+  describe '#ensure_no_line_items' do
+    let!(:line_item) { create(:line_item, variant: variant) }
+
+    it 'should add error on product destroy' do
+      expect(variant.destroy).to eq false
+      expect(variant.errors[:base]).to include Spree.t(:cannot_destroy_if_attached_to_line_items)
+    end
+  end
 end

data/spec/models/spree/zone_member_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Spree::ZoneMember, type: :model do
+  let(:country) { create(:country) }
+  let(:state) { create(:state) }
+  let(:zone) { create(:zone, kind: 'country') }
+  let(:zone_member) { create(:zone_member, zone: zone, zoneable: country) }
+
+  describe 'associations' do
+    it { is_expected.to belong_to(:zoneable) }
+    it { is_expected.to belong_to(:zone).counter_cache(true).inverse_of(:zone_members) }
+  end
+
+  describe 'validations' do
+    it { is_expected.to validate_presence_of(:zone) }
+    it { is_expected.to validate_presence_of(:zoneable) }
+  end
+
+  describe 'scopes' do
+    describe '.defunct_without_kind' do
+      let(:defunct_without_kind) { Spree::ZoneMember.defunct_without_kind('country') }
+
+      context 'zoneable is present and is of defunct kind' do
+        it { expect(defunct_without_kind).to_not include(zone_member) }
+      end
+
+      context 'zoneable is not of defunct kind' do
+        before { zone_member.update(zoneable: state) }
+        it { expect(defunct_without_kind).to include(zone_member) }
+      end
+
+      context 'zoneable is absent' do
+        before { zone_member.update_column(:zoneable_id, nil) }
+        it { expect(defunct_without_kind).to include(zone_member) }
+      end
+    end
+  end
+end

data/spec/models/spree/zone_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Zone, :type => :model do
+describe Spree::Zone, type: :model do
   context "#match" do
     let(:country_zone) { create(:zone, kind: 'country') }
 
@@ -12,8 +12,42 @@ describe Spree::Zone, :type => :model do
       create(:state, country: country)
     end
 
+    it { is_expected.to have_many(:shipping_methods).through(:shipping_method_zones).class_name('Spree::ShippingMethod') }
+
     before { country_zone.members.create(zoneable: country) }
 
+    describe 'scopes' do
+      describe '.remove_previous_default' do
+        let(:zone_with_default_tax) { create(:zone, kind: 'country', default_tax: true) }
+        let(:zone_not_with_default_tax) { create(:zone, kind: 'country', default_tax: false) }
+
+        subject { Spree::Zone.with_default_tax }
+
+        it 'is expected to include zone with default tax' do
+          is_expected.to include(zone_with_default_tax)
+        end
+
+        it 'is expected to not include zone with default tax' do
+          is_expected.to_not include(zone_not_with_default_tax)
+        end
+      end
+    end
+
+    describe 'callbacks' do
+      it { is_expected.to callback(:remove_previous_default).after(:save).if(:default_tax?).if(:default_tax_changed?) }
+
+      describe '#remove_previous_default' do
+        let!(:zone_with_default_tax) { create(:zone, kind: 'country', default_tax: true) }
+        let!(:zone_not_with_default_tax) { create(:zone, kind: 'country', default_tax: false) }
+
+        it 'is expected to make previous default tax zones to non default tax zones' do
+          expect(zone_with_default_tax).to be_default_tax
+          zone_not_with_default_tax.update(default_tax: true)
+          expect(zone_with_default_tax.reload).to_not be_default_tax
+        end
+      end
+    end
+
     context "when there is only one qualifying zone" do
       let(:address) { create(:address, country: country, state: state) }
 
@@ -30,7 +64,9 @@ describe Spree::Zone, :type => :model do
 
       context "when both zones have the same number of members" do
         it "should return the zone that was created first" do
-          expect(Spree::Zone.match(address)).to eq(country_zone)
+          Timecop.scale(100) do
+            expect(Spree::Zone.match(address)).to eq(country_zone)
+          end
         end
       end
 
@@ -373,10 +409,6 @@ describe Spree::Zone, :type => :model do
       it "only returns each zone once" do
         expect(@result.select { |z| z == zone }.size).to be 1
       end
-
-      it "will include the default_tax zone" do
-        expect(@result).to include(default_tax_zone)
-      end
     end
 
     context "finding potential matches for a state zone" do
@@ -410,10 +442,6 @@ describe Spree::Zone, :type => :model do
       it "only returns each zone once" do
         expect(@result.select { |z| z == zone }.size).to be 1
       end
-
-      it "will include the default tax zone" do
-        expect(@result).to include(default_tax_zone)
-      end
     end
   end
 

data/spec/spec_helper.rb

@@ -35,6 +35,8 @@ end
 require 'spree/testing_support/factories'
 require 'spree/testing_support/preferences'
 require 'spree/testing_support/shoulda_matcher_configuration'
+require 'spree/testing_support/url_helpers'
+require 'spree/testing_support/kernel'
 
 RSpec.configure do |config|
   config.color = true
@@ -54,8 +56,11 @@ RSpec.configure do |config|
     reset_spree_preferences
   end
 
+  config.extend WithModel
+
   config.include FactoryGirl::Syntax::Methods
   config.include Spree::TestingSupport::Preferences
+  config.include Spree::TestingSupport::Kernel
 
   # Clean out the database state before the tests run
   config.before(:suite) do

data/spec/support/concerns/{default_price_spec.rb → default_price.rb}

@@ -22,6 +22,15 @@ shared_examples_for "default_price" do
     subject { instance.default_price }
 
     its(:class) { should eql Spree::Price }
+    it 'delegates price' do
+      expect(instance.default_price). to receive(:price)
+      instance.price
+    end
+
+    it 'delegates price_including_vat_for' do
+      expect(instance.default_price). to receive(:price_including_vat_for)
+      instance.price_including_vat_for
+    end
   end
 
   its(:has_default_price?) { should be_truthy }

data/spree_core.gemspec

@@ -8,39 +8,38 @@ Gem::Specification.new do |s|
   s.summary     = 'The bare bones necessary for Spree.'
   s.description = 'The bare bones necessary for Spree.'
 
-  s.required_ruby_version     = '>= 2.1.0'
+  s.required_ruby_version     = '>= 2.2.2'
   s.required_rubygems_version = '>= 1.8.23'
 
   s.author      = 'Sean Schofield'
   s.email       = 'sean@spreecommerce.com'
   s.homepage    = 'http://spreecommerce.com'
-  s.license     = 'BSD-3'
+  s.license     = 'BSD-3-Clause'
 
   s.files        = `git ls-files`.split("\n")
   s.require_path = 'lib'
 
-  s.add_dependency 'activemerchant', '~> 1.47.0'
-  s.add_dependency 'acts_as_list', '0.7.2'
-  s.add_dependency 'awesome_nested_set', '~> 3.0.1'
+  s.add_dependency 'activemerchant', '~> 1.59'
+  s.add_dependency 'acts_as_list', '~> 0.8'
+  s.add_dependency 'awesome_nested_set', '~> 3.1.1'
   s.add_dependency 'carmen', '~> 1.0.0'
   s.add_dependency 'cancancan', '~> 1.10.1'
-  s.add_dependency 'deface', '~> 1.0.0'
-  s.add_dependency 'ffaker', '~> 1.16'
+  s.add_dependency 'deface', '~> 1.0'
+  s.add_dependency 'ffaker', '~> 2.2.0'
   s.add_dependency 'font-awesome-rails', '~> 4.0'
   s.add_dependency 'friendly_id', '~> 5.1.0'
   s.add_dependency 'highline', '~> 1.6.18' # Necessary for the install generator
-  s.add_dependency 'json', '~> 1.7'
-  s.add_dependency 'kaminari', '~> 0.15', '>= 0.15.1'
+  s.add_dependency 'kaminari', '~> 0.17'
   s.add_dependency 'monetize', '~> 1.1'
   s.add_dependency 'paperclip', '~> 4.3.0'
-  s.add_dependency 'paranoia', '~> 2.1.0'
+  s.add_dependency 'paranoia', '~> 2.2.0.pre'
   s.add_dependency 'premailer-rails'
-  s.add_dependency 'rails', '~> 4.2.2'
-  s.add_dependency 'ransack', '~> 1.4.1'
+  s.add_dependency 'acts-as-taggable-on', '~> 4.0'
+  s.add_dependency 'rails', '~> 5.0.0'
+  s.add_dependency 'ransack', '~> 1.8.0'
   s.add_dependency 'responders'
   s.add_dependency 'state_machines-activerecord', '~> 0.2'
   s.add_dependency 'stringex'
-  s.add_dependency 'truncate_html', '0.9.2'
   s.add_dependency 'twitter_cldr', '~> 3.0'
   s.add_dependency 'sprockets-rails'