spree_core 3.0.5 → 3.0.6

data/spec/models/spree/adjustable/adjustments_updater_spec.rb

@@ -0,0 +1,286 @@
+require 'spec_helper'
+
+module Spree
+  module Adjustable
+    describe AdjustmentsUpdater do
+      let(:order) { create :order_with_line_items, line_items_count: 1 }
+      let(:line_item) { order.line_items.first }
+
+      let(:subject) { AdjustmentsUpdater.new(line_item) }
+      let(:order_subject) { AdjustmentsUpdater.new(order) }
+
+      context '#update' do
+        it "updates a linked adjustment" do
+          tax_rate = create(:tax_rate, amount: 0.05)
+          create(:adjustment, order: order, source: tax_rate, adjustable: line_item)
+          line_item.price = 10
+          line_item.tax_category = tax_rate.tax_category
+
+          subject.update
+          expect(line_item.adjustment_total).to eq(0.5)
+          expect(line_item.additional_tax_total).to eq(0.5)
+        end
+      end
+
+      context "taxes and 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 = Calculator::FlatRate.new(preferred_amount: 10)
+          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
+
+      context "best promotion is always applied" do
+        let(:calculator) { Calculator::FlatRate.new(preferred_amount: 10) }
+
+        let(:source) { 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
+
+        it "should make all but the most valuable promotion adjustment ineligible, " +
+           "leaving non promotion adjustments alone" 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
+  end
+end

data/spec/models/spree/adjustment_spec.rb

@@ -0,0 +1,163 @@
+# encoding: utf-8
+#
+
+require 'spec_helper'
+
+describe Spree::Adjustment, :type => :model do
+
+  let(:order) { Spree::Order.new }
+
+  before do
+    allow(order).to receive(:update!)
+  end
+
+  let(:adjustment) { Spree::Adjustment.create!(label: 'Adjustment', adjustable: order, order: order, amount: 5) }
+
+  context '#create & #destroy' do
+    let(:adjustment) { Spree::Adjustment.new(label: "Adjustment", amount: 5, order: order, adjustable: create(:line_item)) }
+
+    it 'calls #update_adjustable_adjustment_total' do
+      expect(adjustment).to receive(:update_adjustable_adjustment_total).twice
+      adjustment.save
+      adjustment.destroy
+    end
+  end
+
+  context '#save' do
+    let(:order) { Spree::Order.create! }
+    let!(:adjustment) { Spree::Adjustment.create(label: "Adjustment", amount: 5, order: order, adjustable: order) }
+
+    it 'touches the adjustable' do
+      expect(adjustment.adjustable).to receive(:touch)
+      adjustment.amount = 3
+      adjustment.save
+    end
+  end
+
+  describe 'non_tax scope' do
+    subject do
+      Spree::Adjustment.non_tax.to_a
+    end
+
+    let!(:tax_adjustment) { create(:adjustment, order: order, source: create(:tax_rate)) }
+    let!(:non_tax_adjustment_with_source) { create(:adjustment, order: order, source_type: 'Spree::Order', source_id: nil) }
+    let!(:non_tax_adjustment_without_source) { create(:adjustment, order: order, source: nil) }
+
+    it 'select non-tax adjustments' do
+      expect(subject).to_not include tax_adjustment
+      expect(subject).to include non_tax_adjustment_with_source
+      expect(subject).to include non_tax_adjustment_without_source
+    end
+  end
+
+  describe 'competing_promos scope' do    
+    before do
+      allow_any_instance_of(Spree::Adjustment).to receive(:update_adjustable_adjustment_total).and_return(true)
+    end
+
+    subject do
+      Spree::Adjustment.competing_promos.to_a
+    end
+
+    let!(:promotion_adjustment) { create(:adjustment, order: order, source_type: 'Spree::PromotionAction', source_id: nil) }
+    let!(:custom_adjustment_with_source) { create(:adjustment, order: order, source_type: 'Custom', source_id: nil) }
+    let!(:non_promotion_adjustment_with_source) { create(:adjustment, order: order, source_type: 'Spree::Order', source_id: nil) }
+    let!(:non_promotion_adjustment_without_source) { create(:adjustment, order: order, source: nil) }
+
+    context 'no custom source_types have been added to competing_promos' do
+      before { Spree::Adjustment.competing_promos_source_types = ['Spree::PromotionAction'] }
+
+      it 'selects promotion adjustments by default' do
+        expect(subject).to include promotion_adjustment
+        expect(subject).to_not include custom_adjustment_with_source
+        expect(subject).to_not include non_promotion_adjustment_with_source
+        expect(subject).to_not include non_promotion_adjustment_without_source
+      end
+    end
+
+    context 'a custom source_type has been added to competing_promos' do
+      before { Spree::Adjustment.competing_promos_source_types = ['Spree::PromotionAction', 'Custom'] }
+
+      it 'selects adjustments with registered source_types' do
+        expect(subject).to include promotion_adjustment
+        expect(subject).to include custom_adjustment_with_source
+        expect(subject).to_not include non_promotion_adjustment_with_source
+        expect(subject).to_not include non_promotion_adjustment_without_source
+      end
+    end
+  end
+
+
+  context "adjustment state" do
+    let(:adjustment) { create(:adjustment, order: order, state: 'open') }
+
+    context "#closed?" do
+      it "is true when adjustment state is closed" do
+        adjustment.state = "closed"
+        expect(adjustment).to be_closed
+      end
+
+      it "is false when adjustment state is open" do
+        adjustment.state = "open"
+        expect(adjustment).to_not be_closed
+      end
+    end
+  end
+
+  context '#currency' do
+    it 'returns the globally configured currency' do
+      expect(adjustment.currency).to eq 'USD'
+    end
+  end
+
+  context "#display_amount" do
+    before { adjustment.amount = 10.55 }
+
+    it "shows the amount" do
+      expect(adjustment.display_amount.to_s).to eq "$10.55"
+    end
+
+    context "with currency set to JPY" do
+      context "when adjustable is set to an order" do
+        before do
+          expect(order).to receive(:currency).and_return('JPY')
+          adjustment.adjustable = order
+        end
+
+        it "displays in JPY" do
+          expect(adjustment.display_amount.to_s).to eq "¥11"
+        end
+      end
+
+      context "when adjustable is nil" do
+        it "displays in the default currency" do
+          expect(adjustment.display_amount.to_s).to eq "$10.55"
+        end
+      end
+    end
+  end
+
+  context '#update!' do
+    context "when adjustment is closed" do
+      before { expect(adjustment).to receive(:closed?).and_return(true) }
+
+      it "does not update the adjustment" do
+        expect(adjustment).to_not receive(:update_column)
+        adjustment.update!
+      end
+    end
+
+    context "when adjustment is open" do
+      before { expect(adjustment).to receive(:closed?).and_return(false) }
+
+      it "updates the amount" do
+        expect(adjustment).to receive(:adjustable).and_return(double("Adjustable")).at_least(1).times
+        expect(adjustment).to receive(:source).and_return(double("Source")).at_least(1).times
+        expect(adjustment.source).to receive("compute_amount").with(adjustment.adjustable).and_return(5)
+        expect(adjustment).to receive(:update_columns).with(amount: 5, updated_at: kind_of(Time))
+        adjustment.update!
+      end
+    end
+  end
+
+end

data/spec/models/spree/app_configuration_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Spree::AppConfiguration, :type => :model do
+
+  let (:prefs) { Rails.application.config.spree.preferences }
+
+  it "should be available from the environment" do
+    prefs.layout = "my/layout"
+    expect(prefs.layout).to eq "my/layout"
+  end
+
+  it "should be available as Spree::Config for legacy access" do
+    Spree::Config.layout = "my/layout"
+    expect(Spree::Config.layout).to eq "my/layout"
+  end
+
+  it "uses base searcher class by default" do
+    prefs.searcher_class = nil
+    expect(prefs.searcher_class).to eq Spree::Core::Search::Base
+  end
+
+end
+