spree_core 3.0.9 → 3.2.0

data/spec/models/spree/address_spec.rb

@@ -1,25 +1,27 @@
 require 'spec_helper'
 
-describe Spree::Address, :type => :model do
+describe Spree::Address, type: :model do
 
-  subject { Spree::Address }
+  describe 'Callbacks' do
+    it { is_expected.to callback(:clear_invalid_state_entities).before(:validation).on(:update) }
+  end
 
   describe "clone" do
     it "creates a copy of the address with the exception of the id, updated_at and created_at attributes" do
       state = create(:state)
       original = create(:address,
-                         :address1 => 'address1',
-                         :address2 => 'address2',
-                         :alternative_phone => 'alternative_phone',
-                         :city => 'city',
-                         :country => Spree::Country.first,
-                         :firstname => 'firstname',
-                         :lastname => 'lastname',
-                         :company => 'company',
-                         :phone => 'phone',
-                         :state_id => state.id,
-                         :state_name => state.name,
-                         :zipcode => '10001')
+                         address1: 'address1',
+                         address2: 'address2',
+                         alternative_phone: 'alternative_phone',
+                         city: 'city',
+                         country: Spree::Country.first,
+                         firstname: 'firstname',
+                         lastname: 'lastname',
+                         company: 'company',
+                         phone: 'phone',
+                         state_id: state.id,
+                         state_name: state.name,
+                         zipcode: '10001')
 
       cloned = original.clone
 
@@ -63,12 +65,12 @@ describe Spree::Address, :type => :model do
       end
     end
 
-    let(:country) { mock_model(Spree::Country, :states => [state], :states_required => true) }
-    let(:state) { stub_model(Spree::State, :name => 'maryland', :abbr => 'md') }
-    let(:address) { build(:address, :country => country) }
+    let(:country) { stub_model(Spree::Country, states: [state], states_required: true) }
+    let(:state) { stub_model(Spree::State, name: 'maryland', abbr: 'md') }
+    let(:address) { build(:address, country: country) }
 
     before do
-      allow(country.states).to receive_messages :find_all_by_name_or_abbr => [state]
+      allow(country.states).to receive_messages find_all_by_name_or_abbr: [state]
     end
 
     it "state_name is not nil and country does not have any states" do
@@ -101,7 +103,7 @@ describe Spree::Address, :type => :model do
 
     it "state is entered but country does not contain that state" do
       address.state = state
-      address.country = stub_model(Spree::Country, :states_required => true)
+      address.country = stub_model(Spree::Country, states_required: true)
       address.valid?
       expect(address.errors["state"]).to eq(['is invalid'])
     end
@@ -109,7 +111,7 @@ describe Spree::Address, :type => :model do
     it "both state and state_name are entered but country does not contain the state" do
       address.state = state
       address.state_name = 'maryland'
-      address.country = stub_model(Spree::Country, :states_required => true)
+      address.country = stub_model(Spree::Country, states_required: true)
       expect(address).to be_valid
       expect(address.state_id).to be_nil
     end
@@ -122,7 +124,7 @@ describe Spree::Address, :type => :model do
     end
 
     it "address_requires_state preference is false" do
-      Spree::Config.set :address_requires_state => false
+      Spree::Config.set address_requires_state: false
       address.state = nil
       address.state_name = nil
       expect(address).to be_valid
@@ -162,6 +164,12 @@ describe Spree::Address, :type => :model do
           expect(address.errors['zipcode']).not_to include('is invalid')
         end
 
+        it 'country does not requires zipcode' do
+          allow(address.country).to receive(:zipcode_required?).and_return(false)
+          address.valid?
+          expect(address.errors['zipcode']).not_to include('is invalid')
+        end
+
         it 'does not have an iso' do
           allow(address.country).to receive(:iso).and_return(nil)
           address.valid?
@@ -227,39 +235,39 @@ describe Spree::Address, :type => :model do
     end
 
     context "user given" do
-      let(:bill_address) { Spree::Address.new(phone: Time.now.to_i) }
+      let(:bill_address) { Spree::Address.new(phone: Time.current.to_i) }
       let(:ship_address) { double("ShipAddress") }
       let(:user) { double("User", bill_address: bill_address, ship_address: ship_address) }
 
       it "returns a copy of that user bill address" do
-        expect(subject.default(user).phone).to eq bill_address.phone
+        expect(Spree::Address.default(user).phone).to eq bill_address.phone
       end
 
       it "falls back to build default when user has no address" do
         allow(user).to receive_messages(bill_address: nil)
-        expect(subject.default(user)).to eq subject.build_default
+        expect(Spree::Address.default(user)).to eq Spree::Address.build_default
       end
     end
   end
 
   context '#full_name' do
     context 'both first and last names are present' do
-      let(:address) { stub_model(Spree::Address, :firstname => 'Michael', :lastname => 'Jackson') }
+      let(:address) { stub_model(Spree::Address, firstname: 'Michael', lastname: 'Jackson') }
       specify { expect(address.full_name).to eq('Michael Jackson') }
     end
 
     context 'first name is blank' do
-      let(:address) { stub_model(Spree::Address, :firstname => nil, :lastname => 'Jackson') }
+      let(:address) { stub_model(Spree::Address, firstname: nil, lastname: 'Jackson') }
       specify { expect(address.full_name).to eq('Jackson') }
     end
 
     context 'last name is blank' do
-      let(:address) { stub_model(Spree::Address, :firstname => 'Michael', :lastname => nil) }
+      let(:address) { stub_model(Spree::Address, firstname: 'Michael', lastname: nil) }
       specify { expect(address.full_name).to eq('Michael') }
     end
 
     context 'both first and last names are blank' do
-      let(:address) { stub_model(Spree::Address, :firstname => nil, :lastname => nil) }
+      let(:address) { stub_model(Spree::Address, firstname: nil, lastname: nil) }
       specify { expect(address.full_name).to eq('') }
     end
 
@@ -267,19 +275,19 @@ describe Spree::Address, :type => :model do
 
   context '#state_text' do
     context 'state is blank' do
-      let(:address) { stub_model(Spree::Address, :state => nil, :state_name => 'virginia') }
+      let(:address) { stub_model(Spree::Address, state: nil, state_name: 'virginia') }
       specify { expect(address.state_text).to eq('virginia') }
     end
 
     context 'both name and abbr is present' do
-      let(:state) { stub_model(Spree::State, :name => 'virginia', :abbr => 'va') }
-      let(:address) { stub_model(Spree::Address, :state => state) }
+      let(:state) { stub_model(Spree::State, name: 'virginia', abbr: 'va') }
+      let(:address) { stub_model(Spree::Address, state: state) }
       specify { expect(address.state_text).to eq('va') }
     end
 
     context 'only name is present' do
-      let(:state) { stub_model(Spree::State, :name => 'virginia', :abbr => nil) }
-      let(:address) { stub_model(Spree::Address, :state => state) }
+      let(:state) { stub_model(Spree::State, name: 'virginia', abbr: nil) }
+      let(:address) { stub_model(Spree::Address, state: state) }
       specify { expect(address.state_text).to eq('virginia') }
     end
   end
@@ -288,4 +296,107 @@ describe Spree::Address, :type => :model do
     let(:address) { stub_model(Spree::Address) }
     specify { expect(address.instance_eval{ require_phone? }).to be true}
   end
+
+  context '#clear_state_entities' do
+    let (:address) { create(:address) }
+    before { address.state_name = 'maryland' }
+
+    it { expect { address.send(:clear_state_entities) }.to change { address.state }.to(nil).from(address.state) }
+    it { expect { address.send(:clear_state_entities) }.to change { address.state_name }.to(nil).from('maryland') }
+  end
+
+  context '#clear_state' do
+    let (:address) { create(:address) }
+    before { address.state_name = 'maryland' }
+
+    it { expect { address.send(:clear_state) }.to change { address.state }.to(nil).from(address.state) }
+    it { expect { address.send(:clear_state) }.to_not change(address, :state_name) }
+  end
+
+  context '#clear_state_name' do
+    let (:address) { create(:address) }
+    before { address.state_name = 'maryland' }
+
+    it { expect { address.send(:clear_state_name) }.to_not change(address, :state_id) }
+    it { expect { address.send(:clear_state_name) }.to change { address.state_name }.to(nil).from('maryland') }
+  end
+
+  context '#clear_invalid_state_entities' do
+    let(:country) { create(:country) }
+    let(:state) { create(:state, country: country) }
+    let (:address) { create(:address, country: country, state: state) }
+
+    def clear_state_entities
+      address.send(:clear_invalid_state_entities)
+    end
+
+    context 'state not present and state_name both not present' do
+      before do
+        address.state = nil
+        address.state_name = nil
+        clear_state_entities
+      end
+
+      it { expect(address.state).to be_nil }
+      it { expect(address.state_name).to be_nil }
+    end
+
+    context 'state_name not present and state present ' do
+      before { address.state_name = nil }
+
+      context 'state belongs to a different country than to which address is associated' do
+        before do
+          address.country = create(:country)
+          clear_state_entities
+        end
+
+        it { expect(address.state).to be_nil }
+        it { expect(address.state_name).to be_nil }
+      end
+
+      context 'state belongs to the same country associated with address' do
+        before { clear_state_entities }
+        it { expect(address.state).to eq(state) }
+        it { expect(address.state_name).to be_nil }
+      end
+    end
+
+    context 'state not present and state_name present' do
+      before do
+        address.state = nil
+        address.state_name = state.name
+      end
+
+      context 'when country has no states and state is required' do
+        before do
+          address.country = create(:country, states_required: true)
+          clear_state_entities
+        end
+
+        it { expect(address.state).to be_nil }
+        it { expect(address.state_name).to eq(state.name) }
+      end
+
+      context 'when country has states' do
+        before do
+          address.state_name = state.name
+          clear_state_entities
+        end
+
+        it { expect(address.state).to be_nil }
+        it { expect(address.state_name).to eq(state.name) }
+      end
+
+      context 'when country has no states and state is not required' do
+        before do
+          address.country = create(:country, states_required: false)
+          address.state_name = state.name
+          clear_state_entities
+        end
+
+        it { expect(address.state).to be_nil }
+        it { expect(address.state_name).to be_nil }
+      end
+    end
+  end
 end

data/spec/models/spree/adjustable/adjuster/base_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Spree::Adjustable::Adjuster::Base, type: :model do
+  let(:line_item) { create(:line_item) }
+  let(:subject) { Spree::Adjustable::Adjuster::Base }
+
+  it "raises missing update method" do
+    expect { subject.adjust(line_item, {}) }.to raise_error(NotImplementedError)
+  end
+end

data/spec/models/spree/adjustable/adjuster/promotion_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+
+describe Spree::Adjustable::Adjuster::Promotion, type: :model do
+  let(:order) { create :order_with_line_items, line_items_count: 1 }
+  let(:line_item) { order.line_items.first }
+  let(:subject) { Spree::Adjustable::AdjustmentsUpdater.new(line_item) }
+  let(:order_subject) { Spree::Adjustable::AdjustmentsUpdater.new(order) }
+
+  context "best promotion is always applied" do
+    let(:calculator) { Spree::Calculator::FlatRate.new(preferred_amount: 10) }
+    let(:source) { Spree::Promotion::Actions::CreateItemAdjustments.create calculator: calculator }
+
+    def create_adjustment(label, amount)
+      create(:adjustment,
+             order: order,
+             adjustable: line_item,
+             source: source,
+             amount: amount,
+             state: "closed",
+             label: label,
+             mandatory: false)
+    end
+
+    describe "competing promos" do
+      before { Spree::Adjustment.competing_promos_source_types = ['Spree::PromotionAction', 'Custom'] }
+
+      it "do not update promo_total" do
+        create(:adjustment,
+               order: order,
+               adjustable: line_item,
+               source_type: 'Custom',
+               source_id: nil,
+               amount: -3.50,
+               label: "Other",
+               mandatory: false)
+        create_adjustment("Promotion A", -2.50)
+
+        subject.update
+        expect(line_item.promo_total).to eql 0.0
+      end
+    end
+
+    it "should use only the most valuable promotion" do
+      create_adjustment("Promotion A", -100)
+      create_adjustment("Promotion B", -200)
+      create_adjustment("Promotion C", -300)
+      create(:adjustment,
+             order: order,
+             adjustable: line_item,
+             source: nil,
+             amount: -500,
+             state: "closed",
+             label: "Some other credit")
+      line_item.adjustments.each { |a| a.update_column(:eligible, true) }
+
+      subject.update
+
+      expect(line_item.adjustments.promotion.eligible.count).to eq(1)
+      expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion C')
+    end
+
+    it "should choose the most recent promotion adjustment when amounts are equal" do
+      # Using Timecop is a regression test
+      Timecop.freeze do
+        create_adjustment("Promotion A", -200)
+        create_adjustment("Promotion B", -200)
+      end
+      line_item.adjustments.each { |a| a.update_column(:eligible, true) }
+
+      subject.update
+
+      expect(line_item.adjustments.promotion.eligible.count).to eq(1)
+      expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion B')
+    end
+
+    context "when previously ineligible promotions become available" do
+      let(:order_promo1) do
+        create(:promotion,
+               :with_order_adjustment,
+               :with_item_total_rule,
+               weighted_order_adjustment_amount: 5,
+               item_total_threshold_amount: 10)
+      end
+
+      let(:order_promo2) do
+        create(:promotion,
+               :with_order_adjustment,
+               :with_item_total_rule,
+               weighted_order_adjustment_amount: 10,
+               item_total_threshold_amount: 20)
+      end
+
+      let(:order_promos) { [order_promo1, order_promo2] }
+
+      let(:line_item_promo1) do
+        create(:promotion,
+               :with_line_item_adjustment,
+               :with_item_total_rule,
+               adjustment_rate: 2.5,
+               item_total_threshold_amount: 10)
+      end
+
+      let(:line_item_promo2) do
+        create(:promotion,
+               :with_line_item_adjustment,
+               :with_item_total_rule,
+               adjustment_rate: 5,
+               item_total_threshold_amount: 20)
+      end
+
+      let(:line_item_promos) { [line_item_promo1, line_item_promo2] }
+      let(:order) { create(:order_with_line_items, line_items_count: 1) }
+
+      # Apply promotions in different sequences. Results should be the same.
+      promo_sequences = [[0, 1], [1, 0]]
+
+      promo_sequences.each do |promo_sequence|
+        it "should pick the best order-level promo according to current eligibility" do
+          # apply both promos to the order, even though only promo1 is eligible
+          order_promos[promo_sequence[0]].activate order: order
+          order_promos[promo_sequence[1]].activate order: order
+
+          order.reload
+          msg = "Expected two adjustments (using sequence #{promo_sequence})"
+          expect(order.all_adjustments.count).to eq(2), msg
+
+          msg = "Expected one elegible adjustment (using sequence #{promo_sequence})"
+          expect(order.all_adjustments.eligible.count).to eq(1), msg
+
+          msg = "Expected promo1 to be used (using sequence #{promo_sequence})"
+          expect(order.all_adjustments.eligible.first.source.promotion).to eq(order_promo1), msg
+
+          order.contents.add create(:variant, price: 10), 1
+          order.save
+
+          order.reload
+          msg = "Expected two adjustments (using sequence #{promo_sequence})"
+          expect(order.all_adjustments.count).to eq(2), msg
+
+          msg = "Expected one elegible adjustment (using sequence #{promo_sequence})"
+          expect(order.all_adjustments.eligible.count).to eq(1), msg
+
+          msg = "Expected promo2 to be used (using sequence #{promo_sequence})"
+          expect(order.all_adjustments.eligible.first.source.promotion).to eq(order_promo2), msg
+        end
+      end
+
+      promo_sequences.each do |promo_sequence|
+        it "should pick the best line-item-level promo according to current eligibility" do
+          # apply both promos to the order, even though only promo1 is eligible
+          line_item_promos[promo_sequence[0]].activate order: order
+          line_item_promos[promo_sequence[1]].activate order: order
+
+          order.reload
+          msg = "Expected one adjustment (using sequence #{promo_sequence})"
+          expect(order.all_adjustments.count).to eq(1), msg
+
+          msg = "Expected one elegible adjustment (using sequence #{promo_sequence})"
+          expect(order.all_adjustments.eligible.count).to eq(1), msg
+
+          # line_item_promo1 is the only one that has thus far met the order total threshold,
+          # it is the only promo which should be applied.
+          msg = "Expected line_item_promo1 to be used (using sequence #{promo_sequence})"
+          expect(order.all_adjustments.first.source.promotion).to eq(line_item_promo1), msg
+
+          order.contents.add create(:variant, price: 10), 1
+          order.save
+
+          order.reload
+          msg = "Expected four adjustments (using sequence #{promo_sequence})"
+          expect(order.all_adjustments.count).to eq(4), msg
+
+          msg = "Expected two elegible adjustments (using sequence #{promo_sequence})"
+          expect(order.all_adjustments.eligible.count).to eq(2), msg
+
+          order.all_adjustments.eligible.each do |adjustment|
+            msg = "Expected line_item_promo2 to be used (using sequence #{promo_sequence})"
+            expect(adjustment.source.promotion).to eq(line_item_promo2), msg
+          end
+        end
+      end
+    end
+
+    context "multiple adjustments and the best one is not eligible" do
+      let!(:promo_a) { create_adjustment("Promotion A", -100) }
+      let!(:promo_c) { create_adjustment("Promotion C", -300) }
+
+      before do
+        promo_a.update_column(:eligible, true)
+        promo_c.update_column(:eligible, false)
+      end
+
+      # regression for #3274
+      it "still makes the previous best eligible adjustment valid" do
+        subject.update
+        expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion A')
+      end
+    end
+
+    it "should only leave one adjustment even if 2 have the same amount" do
+      create_adjustment("Promotion A", -100)
+      create_adjustment("Promotion B", -200)
+      create_adjustment("Promotion C", -200)
+
+      subject.update
+
+      expect(line_item.adjustments.promotion.eligible.count).to eq(1)
+      expect(line_item.adjustments.promotion.eligible.first.amount.to_i).to eq(-200)
+    end
+  end
+end

data/spec/models/spree/adjustable/adjuster/tax_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Spree::Adjustable::Adjuster::Tax, type: :model do
+  let(:order) { create :order_with_line_items, line_items_count: 1 }
+  let(:line_item) { order.line_items.first }
+
+  let(:subject) { Spree::Adjustable::AdjustmentsUpdater.new(line_item) }
+  let(:order_subject) { Spree::Adjustable::AdjustmentsUpdater.new(order) }
+
+  context "taxes with promotions" do
+    let!(:tax_rate) do
+      create(:tax_rate, amount: 0.05)
+    end
+
+    let!(:promotion) do
+      Spree::Promotion.create(name: "$10 off")
+    end
+
+    let!(:promotion_action) do
+      calculator = Spree::Calculator::FlatRate.new(preferred_amount: 10)
+      Spree::Promotion::Actions::CreateItemAdjustments.create(calculator: calculator,
+                                                              promotion: promotion)
+    end
+
+    before do
+      line_item.price = 20
+      line_item.tax_category = tax_rate.tax_category
+      line_item.save
+      create(:adjustment, order: order, source: promotion_action, adjustable: line_item)
+    end
+
+    context "tax included in price" do
+      before do
+        create(:adjustment,
+               source: tax_rate,
+               adjustable: line_item,
+               order: order,
+               included: true)
+      end
+
+      it "tax has no bearing on final price" do
+        subject.update
+        line_item.reload
+        expect(line_item.included_tax_total).to eq(0.5)
+        expect(line_item.additional_tax_total).to eq(0)
+        expect(line_item.promo_total).to eq(-10)
+        expect(line_item.adjustment_total).to eq(-10)
+      end
+
+      it "tax linked to order" do
+        order_subject.update
+        order.reload
+        expect(order.included_tax_total).to eq(0.5)
+        expect(order.additional_tax_total).to eq(00)
+      end
+    end
+
+    context "tax excluded from price" do
+      before do
+        create(:adjustment,
+               source: tax_rate,
+               adjustable: line_item,
+               order: order,
+               included: false)
+      end
+
+      it "tax applies to line item" do
+        subject.update
+        line_item.reload
+        # Taxable amount is: $20 (base) - $10 (promotion) = $10
+        # Tax rate is 5% (of $10).
+        expect(line_item.included_tax_total).to eq(0)
+        expect(line_item.additional_tax_total).to eq(0.5)
+        expect(line_item.promo_total).to eq(-10)
+        expect(line_item.adjustment_total).to eq(-9.5)
+      end
+
+      it "tax linked to order" do
+        order_subject.update
+        order.reload
+        expect(order.included_tax_total).to eq(0)
+        expect(order.additional_tax_total).to eq(0.5)
+      end
+    end
+  end
+end