solidus_core 1.2.3 → 1.3.0.beta1

data/spec/models/spree/variant_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Spree::Variant, :type => :model do
+describe Spree::Variant, type: :model do
   let!(:variant) { create(:variant) }
 
   it_behaves_like 'default_price'
@@ -57,7 +57,7 @@ describe Spree::Variant, :type => :model do
   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
       }
 
@@ -84,37 +84,25 @@ describe Spree::Variant, :type => :model do
           multi_variant.set_option_value('coolness_type', 'awesome')
         }.to change(multi_variant.option_values, :count).by(1)
       end
-    end
-
-    context "product has other variants" do
-      describe "option value accessors" do
-        before {
-          @multi_variant = create(:variant, :product => variant.product)
-          variant.product.reload
-        }
-
-        let(:multi_variant) { @multi_variant }
 
-        it "should set option value" do
-          expect(multi_variant.option_value('media_type')).to be_nil
+      context "and a variant is soft-deleted" do
+        let!(:old_options_text) { variant.options_text }
 
-          multi_variant.set_option_value('media_type', 'DVD')
-          expect(multi_variant.option_value('media_type')).to eql 'DVD'
+        before { variant.destroy }
 
-          multi_variant.set_option_value('media_type', 'CD')
-          expect(multi_variant.option_value('media_type')).to eql 'CD'
+        it "still keeps the option values for that variant" do
+          expect(variant.reload.options_text).to eq(old_options_text)
         end
+      end
 
-        it "should not duplicate associated option values when set multiple times" do
-          multi_variant.set_option_value('media_type', 'CD')
+      context "and a variant is really deleted" do
+        let!(:old_option_values_variant_ids) { variant.option_values_variants.pluck(:id) }
 
-          expect {
-           multi_variant.set_option_value('media_type', 'DVD')
-          }.to_not change(multi_variant.option_values, :count)
+        before { variant.really_destroy! }
 
-          expect {
-            multi_variant.set_option_value('coolness_type', 'awesome')
-          }.to change(multi_variant.option_values, :count).by(1)
+        it "leaves no stale records behind" do
+          expect(old_option_values_variant_ids).to be_present
+          expect(Spree::OptionValuesVariant.where(id: old_option_values_variant_ids)).to be_empty
         end
       end
     end
@@ -143,7 +131,9 @@ describe Spree::Variant, :type => :model do
 
   context "#currency" do
     it "returns the globally configured currency" do
-      expect(variant.currency).to eql "USD"
+      Spree::Deprecation.silence do
+        expect(variant.currency).to eql "USD"
+      end
     end
   end
 
@@ -167,9 +157,9 @@ describe Spree::Variant, :type => :model do
   context "#default_price" do
     context "when multiple prices are present in addition to a default price" do
       before do
-        variant.prices << create(:price, :variant => variant, :currency => "USD", :amount => 12.12, :is_default => false)
-        variant.prices << create(:price, :variant => variant, :currency => "EUR", :amount => 29.99)
-        variant.prices << create(:price, :variant => variant, :currency => "EUR", :amount => 10.00, :is_default => false)
+        variant.prices << create(:price, variant: variant, currency: "USD", amount: 12.12, is_default: false)
+        variant.prices << create(:price, variant: variant, currency: "EUR", amount: 29.99)
+        variant.prices << create(:price, variant: variant, currency: "EUR", amount: 10.00, is_default: false)
         variant.reload
       end
 
@@ -186,23 +176,135 @@ describe Spree::Variant, :type => :model do
     context "when adding multiple prices" do
       it "it can reassign a default price" do
         expect(variant.default_price.amount).to eq(19.99)
-        variant.prices << create(:price, :variant => variant, :currency => "USD", :amount => 12.12)
+        variant.prices << create(:price, variant: variant, currency: "USD", amount: 12.12)
         expect(variant.reload.default_price.amount).to eq(12.12)
       end
     end
   end
 
+  context "#pricer" do
+    subject { variant.pricer }
+
+    it "returns an instance of a pricer" do
+      expect(variant.pricer).to be_a(Spree::Config.variant_pricer_class)
+    end
+
+    it "is instacached" do
+      expect(variant.pricer.object_id).to eq(variant.pricer.object_id)
+    end
+  end
+
+  context "#price_for(price_options)" do
+    let(:price_options) { Spree::Config.variant_pricer_class.pricing_options_class.new }
+
+    it "calls the pricer with the given options object" do
+      expect(variant.pricer).to receive(:price_for).with(price_options)
+      variant.price_for(price_options)
+    end
+  end
+
+  context "#price_difference_from_master" do
+    let(:pricing_options) { Spree::Config.default_pricing_options }
+
+    subject { variant.price_difference_from_master(pricing_options) }
+
+    it "can be called without pricing options" do
+      expect(variant.price_difference_from_master).to eq(Spree::Money.new(0))
+    end
+
+    context "for the master variant" do
+      let(:variant) { create(:product).master }
+
+      it { is_expected.to eq(Spree::Money.new(0, currency: Spree::Config.currency)) }
+    end
+
+    context "when both variants have a price" do
+      let(:product) { create(:product, price: 25) }
+      let(:variant) { create(:variant, product: product, price: 35) }
+
+      it { is_expected.to eq(Spree::Money.new(10, currency: Spree::Config.currency)) }
+    end
+
+    context "when the master variant does not have a price" do
+      let(:product) { create(:product, price: 25) }
+      let(:variant) { create(:variant, product: product, price: 35) }
+
+      before do
+        allow(product.master).to receive(:price_for).and_return(nil)
+      end
+
+      it { is_expected.to be_nil }
+    end
+
+    context "when the variant does not have a price" do
+      let(:product) { create(:product, price: 25) }
+      let(:variant) { create(:variant, product: product, price: 35) }
+
+      before do
+        allow(variant).to receive(:price_for).and_return(nil)
+      end
+
+      it { is_expected.to be_nil }
+    end
+  end
+
+  context "#price_same_as_master?" do
+    context "when the price is the same as the master price" do
+      let(:master) { create(:product, price: 10).master }
+      let(:variant) { create(:variant, price: 10, product: master.product) }
+
+      subject { variant.price_same_as_master? }
+
+      it { is_expected.to be true }
+    end
+
+    context "when the price is different from the master price" do
+      let(:master) { create(:product, price: 11).master }
+      let(:variant) { create(:variant, price: 10, product: master.product) }
+
+      subject { variant.price_same_as_master? }
+
+      it { is_expected.to be false }
+    end
+
+    context "when the master variant does not have a price" do
+      let(:master) { create(:product).master }
+      let(:variant) { create(:variant, price: 10, product: master.product) }
+
+      before do
+        allow(master).to receive(:price_for).and_return(nil)
+      end
+
+      subject { variant.price_same_as_master? }
+
+      it { is_expected.to be_falsey }
+    end
+
+    context "when the variant itself does not have a price" do
+      let(:master) { create(:product).master }
+      let(:variant) { create(:variant, price: 10, product: master.product) }
+
+      before do
+        allow(variant).to receive(:price_for).and_return(nil)
+      end
+
+      subject { variant.price_same_as_master? }
+
+      it { is_expected.to be_falsey }
+    end
+  end
+
   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 }
+    subject { variant.price_in(currency) }
 
     context "when currency is not specified" do
       let(:currency) { nil }
 
-      it "returns 0" do
-        expect(subject.to_s).to eql "$0.00"
+      it "returns nil" do
+        expect(subject).to be_nil
       end
     end
 
@@ -210,7 +312,7 @@ describe Spree::Variant, :type => :model do
       let(:currency) { 'EUR' }
 
       it "returns the value in the EUR" do
-        expect(subject.to_s).to eql "€33.33"
+        expect(subject.display_price.to_s).to eql "€33.33"
       end
     end
 
@@ -218,14 +320,14 @@ describe Spree::Variant, :type => :model do
       let(:currency) { 'USD' }
 
       it "returns the value in the USD" do
-        expect(subject.to_s).to eql "$19.99"
+        expect(subject.display_price.to_s).to eql "$19.99"
       end
     end
   end
 
   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) }
@@ -233,7 +335,7 @@ describe Spree::Variant, :type => :model do
     context "when currency is not specified" do
       let(:currency) { nil }
 
-      it "returns nil" do
+      it "returns the amount in the default currency" do
         expect(subject).to be_nil
       end
     end
@@ -262,14 +364,13 @@ describe Spree::Variant, :type => :model do
 
     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.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') })
     end
 
     it 'should order by bar than foo' do
       expect(variant.options_text).to eql 'Bar Type: Bar, Foo Type: Foo'
     end
-
   end
 
   describe 'exchange_name' do
@@ -295,7 +396,6 @@ describe Spree::Variant, :type => :model do
         expect(variant.exchange_name).to eql 'Foo Type: Foo'
       end
     end
-
   end
 
   describe 'exchange_name' do
@@ -321,7 +421,6 @@ describe Spree::Variant, :type => :model do
         expect(variant.exchange_name).to eql 'Foo Type: Foo'
       end
     end
-
   end
 
   describe 'descriptive_name' do
@@ -347,7 +446,6 @@ describe Spree::Variant, :type => :model do
         expect(variant.descriptive_name).to eql variant.name + ' - Foo Type: Foo'
       end
     end
-
   end
 
   # Regression test for https://github.com/spree/spree/issues/2744
@@ -473,7 +571,6 @@ describe Spree::Variant, :type => :model do
   end
 
   describe "#should_track_inventory?" do
-
     it 'should not track inventory when global setting is off' do
       Spree::Config[:track_inventory_levels] = false
 
@@ -494,10 +591,19 @@ describe Spree::Variant, :type => :model do
   end
 
   describe "deleted_at scope" do
-    before { variant.destroy && variant.reload }
-    it "should have a price if deleted" do
-      variant.price = 10
-      expect(variant.price).to eq(10)
+    let!(:previous_variant_price) { variant.display_price }
+
+    before { variant.destroy }
+
+    it "should keep its price if deleted" do
+      expect(variant.display_price).to eq(previous_variant_price)
+    end
+
+    context 'when loading with pre-fetching of default_price' do
+      it 'also keeps the previous price' do
+        reloaded_variant = Spree::Variant.with_deleted.includes(:default_price).find_by(id: variant.id)
+        expect(reloaded_variant.display_price).to eq(previous_variant_price)
+      end
     end
   end
 
@@ -510,6 +616,7 @@ describe Spree::Variant, :type => :model do
   end
 
   describe "in_stock scope" do
+    subject { Spree::Variant.in_stock }
     let!(:in_stock_variant) { create(:variant) }
     let!(:out_of_stock_variant) { create(:variant) }
     let!(:stock_location) { create(:stock_location) }
@@ -540,8 +647,6 @@ describe Spree::Variant, :type => :model do
     end
 
     context "a stock location is not provided" do
-      subject { Spree::Variant.in_stock }
-
       before do
         in_stock_variant.stock_items.first.update_column(:count_on_hand, 10)
       end
@@ -550,6 +655,15 @@ describe Spree::Variant, :type => :model do
         expect(subject).to eq [in_stock_variant]
       end
     end
+
+    context "inventory levels globally not tracked" do
+      before { Spree::Config.track_inventory_levels = false }
+      after { Spree::Config.track_inventory_levels = true }
+
+      it 'includes items without inventory' do
+        expect( subject ).to include out_of_stock_variant
+      end
+    end
   end
 
   describe "#display_image" do

data/spec/models/spree/zone_spec.rb

@@ -1,12 +1,56 @@
 require 'spec_helper'
 
-describe Spree::Zone, :type => :model do
+describe Spree::Zone, type: :model do
+  describe 'for_address' do
+    let(:new_york_address) { create(:address, state_code: "NY") }
+    let(:alabama_address) { create(:address) }
+    let(:canada_address) { create(:address, country_iso_code: "CA") }
+
+    let!(:new_york_zone) { create(:zone, states: [new_york_address.state]) }
+    let!(:alabama_zone) { create(:zone, states: [alabama_address.state]) }
+    let!(:united_states_zone) { create(:zone, countries: [new_york_address.country]) }
+    let!(:canada_zone) { create(:zone, countries: [canada_address.country]) }
+    let!(:north_america_zone) { create(:zone, countries: [canada_address.country, new_york_address.country]) }
+    subject { Spree::Zone.for_address(address) }
+
+    context 'when there is no address' do
+      let(:address) { nil }
+      it 'returns an empty relation' do
+        expect(subject).to eq([])
+      end
+    end
+
+    context 'for an address in New York' do
+      let(:address) { new_york_address }
+
+      it 'matches the New York zone' do
+        expect(subject).to include(new_york_zone)
+      end
+
+      it 'matches the United States zone' do
+        expect(subject).to include(united_states_zone)
+      end
+
+      it 'does not match the Alabama zone' do
+        expect(subject).not_to include(alabama_zone)
+      end
+
+      it 'does not match the Canadian zone' do
+        expect(subject).not_to include(canada_zone)
+      end
+
+      it 'matches the North America zone' do
+        expect(subject).to include(north_america_zone)
+      end
+    end
+  end
+
   context "#match" do
     let(:country_zone) { create(:zone, name: 'CountryZone') }
     let(:country) do
       country = create(:country)
       # Create at least one state for this country
-      state = create(:state, country: country)
+      create(:state, country: country)
       country
     end
 
@@ -115,7 +159,7 @@ describe Spree::Zone, :type => :model do
       before { @foo_zone = create(:zone, name: 'whatever', default_tax: true) }
 
       it "should be the correct zone" do
-        foo_zone = create(:zone, name: 'foo')
+        create(:zone, name: 'foo')
         expect(Spree::Zone.default_tax).to eq(@foo_zone)
       end
     end
@@ -229,7 +273,6 @@ describe Spree::Zone, :type => :model do
       before { @source.members.create(zoneable: country1) }
 
       context "when all states contained in one of the countries we check against" do
-
         before do
           state1 = create(:state, country: country1)
           @target.members.create(zoneable: state1)
@@ -241,7 +284,6 @@ describe Spree::Zone, :type => :model do
       end
 
       context "when some states contained in one of the countries we check against" do
-
         before do
           state1 = create(:state, country: country1)
           @target.members.create(zoneable: state1)
@@ -254,7 +296,6 @@ describe Spree::Zone, :type => :model do
       end
 
       context "when none of the states contained in any of the countries we check against" do
-
         before do
           @target.members.create(zoneable: create(:state, country: country2))
           @target.members.create(zoneable: create(:state, country: country2))
@@ -265,14 +306,13 @@ describe Spree::Zone, :type => :model do
         end
       end
     end
-
   end
 
   context "#save" do
     context "when default_tax is true" do
       it "should clear previous default tax zone" do
         zone1 = create(:zone, name: 'foo', default_tax: true)
-        zone = create(:zone, name: 'bar', default_tax: true)
+        create(:zone, name: 'bar', default_tax: true)
         expect(zone1.reload.default_tax).to be false
       end
     end
@@ -313,7 +353,7 @@ describe Spree::Zone, :type => :model do
   end
 
   context "state and country associations" do
-    let!(:country)  { create(:country) }
+    let!(:country) { create(:country) }
 
     context "has countries associated" do
       let!(:zone) do
@@ -326,7 +366,7 @@ describe Spree::Zone, :type => :model do
     end
 
     context "has states associated" do
-      let!(:state)  { create(:state, country: country) }
+      let!(:state) { create(:state, country: country) }
       let!(:zone) do
         create(:zone, states: [state])
       end
@@ -336,4 +376,89 @@ describe Spree::Zone, :type => :model do
       end
     end
   end
+
+  context ".with_shared_members" do
+    let!(:country)  { create(:country) }
+    let!(:country2) { create(:country, name: 'OtherCountry') }
+    let!(:country3) { create(:country, name: 'TaxCountry') }
+
+    subject(:zones_with_shared_members) { Spree::Zone.with_shared_members(zone) }
+
+    context 'when passing a zone with no members' do
+      let!(:zone) { create :zone }
+
+      it 'will return an empty set' do
+        expect(subject).to eq([])
+      end
+    end
+
+    context 'when passing nil' do
+      let!(:zone) { nil }
+
+      it 'will return an empty set' do
+        expect(subject).to eq([])
+      end
+    end
+
+    context "finding potential matches for a country zone" do
+      let!(:zone) do
+        create(:zone).tap do |z|
+          z.members.create(zoneable: country)
+          z.members.create(zoneable: country2)
+          z.save!
+        end
+      end
+
+      let!(:zone2) do
+        create(:zone).tap { |z| z.members.create(zoneable: country) && z.save! }
+      end
+
+      let!(:zone3) do
+        create(:zone).tap { |z| z.members.create(zoneable: country3) && z.save! }
+      end
+
+      it "will find all zones with countries covered by the passed in zone" do
+        expect(zones_with_shared_members).to include(zone, zone2)
+      end
+
+      it "will not return zones with countries not covered in the passed in zone" do
+        expect(zones_with_shared_members).not_to include(zone3)
+      end
+
+      it "only returns each zone once" do
+        expect(zones_with_shared_members.select { |z| z == zone }.size).to be 1
+      end
+    end
+
+    context "finding potential matches for a state zone" do
+      let!(:state)  { create(:state, country: country) }
+      let!(:state2) { create(:state, country: country2, name: 'OtherState') }
+      let!(:state3) { create(:state, country: country2, name: 'State') }
+      let!(:zone) do
+        create(:zone).tap do |z|
+          z.members.create(zoneable: state)
+          z.members.create(zoneable: state2)
+          z.save!
+        end
+      end
+      let!(:zone2) do
+        create(:zone).tap { |z| z.members.create(zoneable: state) && z.save! }
+      end
+      let!(:zone3) do
+        create(:zone).tap { |z| z.members.create(zoneable: state2) && z.save! }
+      end
+
+      it "will find all zones which share states covered by passed in zone" do
+        expect(zones_with_shared_members).to include(zone, zone2)
+      end
+
+      it "will find zones that share countries with any states of the passed in zone" do
+        expect(zones_with_shared_members).to include(zone3)
+      end
+
+      it "only returns each zone once" do
+        expect(zones_with_shared_members.select { |z| z == zone }.size).to be 1
+      end
+    end
+  end
 end

data/spec/support/big_decimal.rb

@@ -1,5 +1,5 @@
 class BigDecimal
   def inspect
-    "#<BigDecimal: #{to_s}>"
+    "#<BigDecimal: #{self}>"
   end
 end

data/spec/support/concerns/working_factories.rb

@@ -1,9 +1,9 @@
 RSpec.shared_examples_for 'a working factory' do
   it "builds successfully" do
-    expect(build factory).to be_a(factory_class)
+    expect(build(factory)).to be_a(factory_class)
   end
 
   it "creates successfully" do
-    expect(create factory).to be_a(factory_class)
+    expect(create(factory)).to be_a(factory_class)
   end
 end

data/spec/support/dummy_ability.rb

@@ -1,4 +1,3 @@
 class DummyAbility
   include CanCan::Ability
 end
-